def get_vector_scene(self, class_id, use_aoi=False): gt_uri = data_file_path('{}-gt-polygons.geojson'.format(class_id)) pred_uri = data_file_path('{}-pred-polygons.geojson'.format(class_id)) scene_id = str(class_id) rs = MockRasterSource(channel_order=[0, 1, 3], num_channels=3) rs.set_raster(np.zeros((10, 10, 3))) crs_transformer = IdentityCRSTransformer() extent = Box.make_square(0, 0, 360) gt_rs = RasterizedSource(GeoJSONVectorSource(gt_uri, crs_transformer), RasterizedSourceConfig.RasterizerOptions(2), extent, crs_transformer) gt_ls = SemanticSegmentationLabelSource(source=gt_rs) pred_rs = RasterizedSource( GeoJSONVectorSource(pred_uri, crs_transformer), RasterizedSourceConfig.RasterizerOptions(2), extent, crs_transformer) pred_ls = SemanticSegmentationLabelSource(source=pred_rs) pred_ls.vector_output = [{ 'uri': pred_uri, 'denoise': 0, 'mode': 'polygons', 'class_id': class_id }] if use_aoi: aoi_uri = data_file_path('{}-aoi.geojson'.format(class_id)) aoi_geojson = json.loads(file_to_str(aoi_uri)) aoi_polygons = [shape(aoi_geojson['features'][0]['geometry'])] return Scene(scene_id, rs, gt_ls, pred_ls, aoi_polygons) return Scene(scene_id, rs, gt_ls, pred_ls)
def test_accounts_for_aoi(self): class_config = ClassConfig(names=['car', 'building', 'background']) label_source_uri = data_file_path('evaluator/cc-label-filtered.json') label_source_cfg = ChipClassificationLabelSourceConfig( vector_source=GeoJSONVectorSourceConfig( uri=label_source_uri, default_class_id=None)) label_store_uri = data_file_path('evaluator/cc-label-full.json') label_store_cfg = ChipClassificationGeoJSONStoreConfig( uri=label_store_uri) raster_source_uri = data_file_path('evaluator/cc-label-img-blank.tif') raster_source_cfg = RasterioSourceConfig(uris=[raster_source_uri]) aoi_uri = data_file_path('evaluator/cc-label-aoi.json') s = SceneConfig( id='test', raster_source=raster_source_cfg, label_source=label_source_cfg, label_store=label_store_cfg, aoi_uris=[aoi_uri]) with rv_config.get_tmp_dir() as tmp_dir: scene = s.build(class_config, tmp_dir) output_uri = os.path.join(tmp_dir, 'eval.json') evaluator = ChipClassificationEvaluatorConfig( output_uri=output_uri).build(class_config) evaluator.process([scene], tmp_dir) overall = file_to_json(output_uri)['overall'] for item in overall: self.assertEqual(item['f1'], 1.0)
def test_make_predict_windows_with_aoi(self): task_config = rv.TaskConfig.builder(rv.CHIP_CLASSIFICATION) \ .with_chip_size(200) \ .with_classes(['car', 'building', 'background']) \ .build() backend_config = rv.BackendConfig.builder(rv.KERAS_CLASSIFICATION) \ .with_task(task_config) \ .with_model_defaults(rv.RESNET50_IMAGENET) \ .with_pretrained_model(None) \ .build() label_source_uri = data_file_path('evaluator/cc-label-full.json') label_source = rv.LabelSourceConfig.builder(rv.CHIP_CLASSIFICATION_GEOJSON) \ .with_uri(label_source_uri) \ .build() label_source_2_uri = data_file_path('evaluator/cc-label-filtered.json') label_source_2 = rv.LabelSourceConfig.builder(rv.CHIP_CLASSIFICATION_GEOJSON) \ .with_uri(label_source_2_uri) \ .build() source_uri = data_file_path('evaluator/cc-label-img-blank.tif') raster_source = rv.RasterSourceConfig.builder(rv.RASTERIO_SOURCE) \ .with_uri(source_uri) \ .build() aoi_uri = data_file_path('evaluator/cc-label-aoi.json') s = rv.SceneConfig.builder() \ .with_id('test') \ .with_raster_source(raster_source) \ .with_label_source(label_source) \ .with_aoi_uri(aoi_uri) \ .build() with RVConfig.get_tmp_dir() as tmp_dir: scene = s.create_scene(task_config, tmp_dir) backend = backend_config.create_backend(task_config) task = task_config.create_task(backend) with scene.activate(): windows = task.get_train_windows(scene) from rastervision.data import (ChipClassificationLabels, ChipClassificationGeoJSONStore) labels = ChipClassificationLabels() for w in windows: labels.set_cell(w, 1) store = ChipClassificationGeoJSONStore( os.path.join(tmp_dir, 'test.json'), scene.raster_source.get_crs_transformer(), task_config.class_map) store.save(labels) ls = label_source_2.create_source( task_config, scene.raster_source.get_extent(), scene.raster_source.get_crs_transformer(), tmp_dir) actual = ls.get_labels().get_cells() self.assertEqual(len(windows), len(actual))
def test_nonidentical_extents_and_resolutions(self): img_path_1 = data_file_path( 'multi_raster_source/const_100_600x600.tiff') img_path_2 = data_file_path('multi_raster_source/const_175_60x60.tiff') img_path_3 = data_file_path('multi_raster_source/const_250_6x6.tiff') source_1 = RasterioSourceConfig(uris=[img_path_1], channel_order=[0]) source_2 = RasterioSourceConfig(uris=[img_path_2], channel_order=[0]) source_3 = RasterioSourceConfig(uris=[img_path_3], channel_order=[0]) cfg = MultiRasterSourceConfig(raster_sources=[ SubRasterSourceConfig(raster_source=source_1, target_channels=[0]), SubRasterSourceConfig(raster_source=source_2, target_channels=[1]), SubRasterSourceConfig(raster_source=source_3, target_channels=[2]) ]) rs = cfg.build(tmp_dir=self.tmp_dir) with rs.activate(): for get_chip_fn in [rs._get_chip, rs.get_chip]: ch_1_only = get_chip_fn(Box(0, 0, 10, 10)) self.assertEqual(tuple(ch_1_only.reshape(-1, 3).mean(axis=0)), (100, 0, 0)) ch_2_only = get_chip_fn(Box(0, 600, 10, 600 + 10)) self.assertEqual(tuple(ch_2_only.reshape(-1, 3).mean(axis=0)), (0, 175, 0)) ch_3_only = get_chip_fn(Box(600, 0, 600 + 10, 10)) self.assertEqual(tuple(ch_3_only.reshape(-1, 3).mean(axis=0)), (0, 0, 250)) full_img = get_chip_fn(Box(0, 0, 600, 600)) self.assertEqual(set(np.unique(full_img[..., 0])), {100}) self.assertEqual(set(np.unique(full_img[..., 1])), {0, 175}) self.assertEqual(set(np.unique(full_img[..., 2])), {0, 250})
def test_accounts_for_aoi(self): task = rv.TaskConfig.builder(rv.CHIP_CLASSIFICATION) \ .with_classes(['car', 'building', 'background']) \ .build() label_source_uri = data_file_path('evaluator/cc-label-filtered.json') label_source = rv.LabelSourceConfig.builder(rv.CHIP_CLASSIFICATION_GEOJSON) \ .with_uri(label_source_uri) \ .build() label_store_uri = data_file_path('evaluator/cc-label-full.json') label_store = rv.LabelStoreConfig.builder(rv.CHIP_CLASSIFICATION_GEOJSON) \ .with_uri(label_store_uri) \ .build() source_uri = data_file_path('evaluator/cc-label-img-blank.tif') raster_source = rv.RasterSourceConfig.builder(rv.GEOTIFF_SOURCE) \ .with_uri(source_uri) \ .build() aoi_uri = data_file_path('evaluator/cc-label-aoi.json') s = rv.SceneConfig.builder() \ .with_id('test') \ .with_raster_source(raster_source) \ .with_label_source(label_source) \ .with_label_store(label_store) \ .with_aoi_uri(aoi_uri) \ .build() with RVConfig.get_tmp_dir() as tmp_dir: scene = s.create_scene(task, tmp_dir) output_uri = os.path.join(tmp_dir, 'eval.json') e = rv.EvaluatorConfig.builder(rv.CHIP_CLASSIFICATION_EVALUATOR) \ .with_task(task) \ .with_output_uri(output_uri) \ .build() e.update_for_command(rv.EVAL, create_mock_experiment()) evaluator = e.create_evaluator() evaluator.process([scene], tmp_dir) results = None with open(output_uri) as f: results = json.loads(f.read())['overall'] for result in results: self.assertEqual(result['f1'], 1.0)
def test_command_create_no_compression(self): src_path = data_file_path('small-rgb-tile.tif') with RVConfig.get_tmp_dir() as tmp_dir: cog_path = os.path.join(tmp_dir, 'cog.tif') cmd_conf = rv.CommandConfig.builder(rv.COGIFY) \ .with_root_uri(tmp_dir) \ .with_config(uris=[(src_path, cog_path)], block_size=128, compression='none') \ .build() cmd_conf = rv.command.CommandConfig.from_proto(cmd_conf.to_proto()) cmd = cmd_conf.create_command() self.assertTrue(cmd, rv.command.aux.CogifyCommand) cmd.run(tmp_dir) # Check that it's cogified with rasterio.open(cog_path) as ds: self.assertEqual(ds.block_shapes, [(128, 128), (128, 128), (128, 128)]) self.assertEqual(ds.overviews(1), [2, 4, 8, 16, 32]) self.assertIsNone(ds.compression)
def test_command_through_experiment(self): src_path = data_file_path('small-rgb-tile.tif') with RVConfig.get_tmp_dir() as tmp_dir: cog_path = os.path.join(tmp_dir, 'cog.tif') e = mk.create_mock_experiment().to_builder() \ .with_root_uri(tmp_dir) \ .with_custom_config({ 'cogify': { 'key': 'test', 'config': { 'uris': [(src_path, cog_path)], 'block_size': 128 } } }) \ .build() rv.ExperimentRunner.get_runner(rv.LOCAL).run( e, splits=2, commands_to_run=[rv.COGIFY]) # Check that it's cogified with rasterio.open(cog_path) as ds: self.assertEqual(ds.block_shapes, [(128, 128), (128, 128), (128, 128)]) self.assertEqual(ds.overviews(1), [2, 4, 8, 16, 32])
def test_get_dtype(self): img_path = data_file_path('small-rgb-tile.tif') with RVConfig.get_tmp_dir() as tmp_dir: source = rv.data.RasterioSourceConfig(uris=[img_path]) \ .create_source(tmp_dir) self.assertEqual(source.get_dtype(), np.uint8)
def test_gets_raw_chip_from_uint16_transformed_proto(self): img_path = data_file_path('small-uint16-tile.tif') channel_order = [0, 1] with RVConfig.get_tmp_dir() as temp_dir: stats_uri = os.path.join(temp_dir, 'temp.tif') stats = RasterStats() stats.compute([ rv.RasterSourceConfig.builder(rv.RASTERIO_SOURCE).with_uri( img_path).build().create_source(temp_dir) ]) stats.save(stats_uri) transformer = rv.RasterTransformerConfig.builder(rv.STATS_TRANSFORMER) \ .with_stats_uri(stats_uri) \ .build() msg = rv.RasterSourceConfig.builder(rv.RASTERIO_SOURCE) \ .with_uri(img_path) \ .with_channel_order(channel_order) \ .with_transformer(transformer) \ .build() \ .to_proto() source = rv.RasterSourceConfig.from_proto(msg) \ .create_source(tmp_dir=None) with source.activate(): out_chip = source.get_raw_image_array() self.assertEqual(out_chip.shape[2], 3)
def test_read_stac(self): expected_keys = { 'label_uri': str, 'image_uris': list, 'label_bbox': Polygon, 'image_bbox': (type(None), Polygon), 'bboxes_intersect': bool, 'aoi_geometry': (type(None), dict) } zip_path = data_file_path('catalog.zip') with TemporaryDirectory(dir='/opt/data/tmp') as tmp_dir: out = read_stac(zip_path, tmp_dir) # check for correctness of format self.assertIsInstance(out, list) for o in out: self.assertIsInstance(o, dict) for k, v in o.items(): self.assertTrue(k in expected_keys) self.assertIsInstance(v, expected_keys[k]) for uri in o['image_uris']: self.assertIsInstance(uri, str) # check for correctness of content (WRT the test catalog) self.assertEqual(len(out), 1) self.assertEqual(len(out[0]['image_uris']), 1) for o in out: label_uri = o['label_uri'] self.assertTrue(os.path.exists(label_uri)) self.assertTrue(label_uri.startswith(tmp_dir))
def test_with_aoi(self): aoi_uri = data_file_path('evaluator/cc-label-aoi.json') task_config = rv.TaskConfig.builder(mk.MOCK_TASK).build() scene_config = mk.create_mock_scene() scene_config = scene_config.to_builder().with_aoi_uri(aoi_uri).build() scene = scene_config.create_scene(task_config, self.temp_dir.name) self.assertEqual(1, len(scene.aoi_polygons))
def get_base(self): root_uri = '/some/dummy/root' img_path = '/dummy.tif' label_path = '/dummy.json' backend_conf_path = data_file_path( 'tf_object_detection/' 'embedded_ssd_mobilenet_v1_coco.config') pretrained_model = ('https://dummy.com/model.gz') task = rv.TaskConfig.builder(rv.OBJECT_DETECTION) \ .with_chip_size(300) \ .with_classes({ 'car': (1, 'blue'), 'building': (2, 'red') }) \ .with_chip_options(neg_ratio=0.0, ioa_thresh=1.0, window_method='sliding') \ .with_predict_options(merge_thresh=0.1, score_thresh=0.5) \ .build() backend = rv.BackendConfig.builder(rv.TF_OBJECT_DETECTION) \ .with_task(task) \ .with_template(backend_conf_path) \ .with_pretrained_model(pretrained_model) \ .with_train_options(sync_interval=None, do_monitoring=False) \ .build() raster_source = rv.RasterSourceConfig.builder(rv.RASTERIO_SOURCE) \ .with_uri(img_path) \ .with_channel_order([0, 1, 2]) \ .with_stats_transformer() \ .build() scene = rv.SceneConfig.builder() \ .with_task(task) \ .with_id('od_test') \ .with_raster_source(raster_source) \ .with_label_source(label_path) \ .build() dataset = rv.DatasetConfig.builder() \ .with_train_scene(scene) \ .with_validation_scene(scene) \ .build() analyzer = rv.analyzer.StatsAnalyzerConfig() return rv.ExperimentConfig.builder() \ .with_root_uri(root_uri) \ .with_task(task) \ .with_backend(backend) \ .with_dataset(dataset) \ .with_analyzer(analyzer) \ .with_train_key('model_name')
def test_evaluator(self): output_uri = join(self.tmp_dir.name, 'out.json') scenes = [self.get_scene(0), self.get_scene(1)] evaluator = SemanticSegmentationEvaluator(self.class_config, output_uri, None) evaluator.process(scenes, self.tmp_dir.name) eval_json = file_to_json(output_uri) exp_eval_json = file_to_json(data_file_path('expected-eval.json')) self.assertDictEqual(eval_json, exp_eval_json)
def test_using_null_class_bufs(self): uri = data_file_path('polygon-labels.geojson') vs = rv.VectorSourceConfig.builder(rv.GEOJSON_SOURCE) \ .with_uri(uri) \ .with_buffers(line_bufs={1: None}) \ .build() with self.assertRaises(rv.ConfigError): rv.LabelSourceConfig.builder(rv.OBJECT_DETECTION) \ .with_vector_source(vs) \ .build()
def test_gets_raw_chip(self): img_path = data_file_path('small-rgb-tile.tif') channel_order = [0, 1] config = RasterioSourceConfig( uris=[img_path], channel_order=channel_order) source = config.build(tmp_dir=self.tmp_dir) with source.activate(): out_chip = source.get_raw_image_array() self.assertEqual(out_chip.shape[2], 3)
def test_vector_compute(self): class_map = ClassMap([ClassItem(id=1, name='one', color='#000021')]) gt_uri = data_file_path('3-gt-polygons.geojson') pred_uri = data_file_path('3-pred-polygons.geojson') eval = SemanticSegmentationEvaluation(class_map) eval.compute_vector(gt_uri, pred_uri, 'polygons', 1) # NOTE: The two geojson files referenced above contain three # unique geometries total, each file contains two geometries, # and there is one geometry shared between the two. tp = 1.0 fp = 1.0 fn = 1.0 precision = float(tp) / (tp + fp) recall = float(tp) / (tp + fn) self.assertAlmostEqual(precision, eval.class_to_eval_item[1].precision) self.assertAlmostEqual(recall, eval.class_to_eval_item[1].recall)
def test_with_aoi_back_compat(self): aoi_uri = data_file_path('evaluator/cc-label-aoi.json') task_config = rv.TaskConfig.builder(mk.MOCK_TASK).build() scene_config = mk.create_mock_scene() scene_msg = scene_config.to_proto() # Use deprecated aoi_uri field. del scene_msg.aoi_uris[:] scene_msg.aoi_uri = aoi_uri scene_config = rv.SceneConfig.from_proto(scene_msg) scene = scene_config.create_scene(task_config, self.temp_dir.name) self.assertEqual(1, len(scene.aoi_polygons))
def test_gets_raw_chip(self): img_path = data_file_path('small-rgb-tile.tif') channel_order = [0, 1] source = rv.data.RasterioSourceConfig(uris=[img_path], channel_order=channel_order) \ .create_source(tmp_dir=None) with source.activate(): out_chip = source.get_raw_image_array() self.assertEqual(out_chip.shape[2], 3)
def get_backend(task, tmp_dir): model_uri = os.path.join(tmp_dir, 'model') template_uri = data_file_path( 'tf_object_detection/embedded_ssd_mobilenet_v1_coco.config') with open(model_uri, 'w') as f: f.write('DUMMY') b = rv.BackendConfig.builder(rv.TF_OBJECT_DETECTION) \ .with_task(task) \ .with_template(template_uri) \ .with_model_uri(model_uri) \ .build() return b
def test_extent_crop(self): f = 1 / 4 img_path = data_file_path('small-rgb-tile.tif') cfg_crop = RasterioSourceConfig( uris=[img_path], extent_crop=(f, f, f, f)) rs_crop = cfg_crop.build(tmp_dir=self.tmp_dir) # test extent box extent_crop = rs_crop.get_extent() self.assertEqual(extent_crop.ymin, 64) self.assertEqual(extent_crop.xmin, 64) self.assertEqual(extent_crop.ymax, 192) self.assertEqual(extent_crop.xmax, 192) # test windows windows = extent_crop.get_windows(64, 64) self.assertEqual(windows[0].ymin, 64) self.assertEqual(windows[0].xmin, 64) self.assertEqual(windows[-1].ymax, 192) self.assertEqual(windows[-1].xmax, 192) # test CropOffsets class cfg_crop = RasterioSourceConfig( uris=[img_path], extent_crop=CropOffsets(skip_top=.5, skip_right=.5)) rs_crop = cfg_crop.build(tmp_dir=self.tmp_dir) extent_crop = rs_crop.get_extent() self.assertEqual(extent_crop.ymin, 128) self.assertEqual(extent_crop.xmin, 0) self.assertEqual(extent_crop.ymax, 256) self.assertEqual(extent_crop.xmax, 128) # test validation extent_crop = CropOffsets(skip_top=.5, skip_bottom=.5) self.assertRaises( ValidationError, lambda: RasterioSourceConfig(uris=[img_path], extent_crop=extent_crop)) extent_crop = CropOffsets(skip_left=.5, skip_right=.5) self.assertRaises( ValidationError, lambda: RasterioSourceConfig(uris=[img_path], extent_crop=extent_crop)) # test extent_crop=None try: _ = RasterioSourceConfig(uris=[img_path], extent_crop=None) # noqa except Exception: self.fail('extent_crop=None caused an error.')
def test_extent(self): img_path = data_file_path('small-rgb-tile.tif') cfg = RasterioSourceConfig(uris=[img_path]) rs = cfg.build(tmp_dir=self.tmp_dir) extent = rs.get_extent() h, w = extent.get_height(), extent.get_width() ymin, xmin, ymax, xmax = extent self.assertEqual(h, 256) self.assertEqual(w, 256) self.assertEqual(ymin, 0) self.assertEqual(xmin, 0) self.assertEqual(ymax, 256) self.assertEqual(xmax, 256)
def make_cfg(img_path='small-rgb-tile.tif', **kwargs): img_path = data_file_path(img_path) r_source = RasterioSourceConfig(uris=[img_path], channel_order=[0]) g_source = RasterioSourceConfig(uris=[img_path], channel_order=[1]) b_source = RasterioSourceConfig(uris=[img_path], channel_order=[2]) cfg = MultiRasterSourceConfig(raster_sources=[ SubRasterSourceConfig(raster_source=r_source, target_channels=[0]), SubRasterSourceConfig(raster_source=g_source, target_channels=[1]), SubRasterSourceConfig(raster_source=b_source, target_channels=[2]) ], **kwargs) return cfg
def test_vector_compute(self): class_config = ClassConfig(names=['one', 'two']) class_config.update() class_config.ensure_null_class() gt_uri = data_file_path('2-gt-polygons.geojson') pred_uri = data_file_path('2-pred-polygons.geojson') eval = SemanticSegmentationEvaluation(class_config) eval.compute_vector(gt_uri, pred_uri, 'polygons', 0) # NOTE: The two geojson files referenced above contain three # unique geometries total, each file contains two geometries, # and there is one geometry shared between the two. tp = 1.0 fp = 1.0 fn = 1.0 precision = float(tp) / (tp + fp) recall = float(tp) / (tp + fn) self.assertAlmostEqual(precision, eval.class_to_eval_item[0].precision) self.assertAlmostEqual(recall, eval.class_to_eval_item[0].recall)
def test_evaluator(self): class_map = ClassMap([ ClassItem(id=1, name='one'), ClassItem(id=2, name='two'), ]) output_uri = join(self.tmp_dir.name, 'out.json') scenes = [self.get_scene(1), self.get_scene(2)] evaluator = SemanticSegmentationEvaluator(class_map, output_uri, None) evaluator.process(scenes, self.tmp_dir.name) eval_json = json.loads(file_to_str(output_uri)) exp_eval_json = json.loads( file_to_str(data_file_path('expected-eval.json'))) self.assertDictEqual(eval_json, exp_eval_json)
def _test_get_geojson(self, vector_tile_uri, json_uri): source = self._get_source(vector_tile_uri) geojson = source.get_geojson() expected_geojson = json.loads(file_to_str(data_file_path(json_uri))) # Need to convert to JSON and back again because geojson object has tuples # instead of lists because of a quirk of shapely.geometry.mapping # See https://github.com/Toblerity/Shapely/issues/245 geojson = json.loads(json.dumps(geojson)) geojson['features'].sort(key=lambda f: f['properties']['__id']) expected_geojson['features'].sort( key=lambda f: f['properties']['__id']) self.assertDictEqual(geojson, expected_geojson)
def get_vector_scene(self, class_id, use_aoi=False): gt_uri = data_file_path('{}-gt-polygons.geojson'.format(class_id)) pred_uri = data_file_path('{}-pred-polygons.geojson'.format(class_id)) scene_id = str(class_id) rs = MockRasterSource(channel_order=[0, 1, 3], num_channels=3) rs.set_raster(np.zeros((10, 10, 3))) crs_transformer = IdentityCRSTransformer() extent = Box.make_square(0, 0, 360) config = RasterizedSourceConfig( vector_source=GeoJSONVectorSourceConfig(uri=gt_uri, default_class_id=0), rasterizer_config=RasterizerConfig(background_class_id=1)) gt_rs = config.build(self.class_config, crs_transformer, extent) gt_ls = SemanticSegmentationLabelSource(gt_rs, self.null_class_id) config = RasterizedSourceConfig( vector_source=GeoJSONVectorSourceConfig(uri=pred_uri, default_class_id=0), rasterizer_config=RasterizerConfig(background_class_id=1)) pred_rs = config.build(self.class_config, crs_transformer, extent) pred_ls = SemanticSegmentationLabelSource(pred_rs, self.null_class_id) pred_ls.vector_output = [ PolygonVectorOutputConfig(uri=pred_uri, denoise=0, class_id=class_id) ] if use_aoi: aoi_uri = data_file_path('{}-aoi.geojson'.format(class_id)) aoi_geojson = file_to_json(aoi_uri) aoi_polygons = [shape(aoi_geojson['features'][0]['geometry'])] return Scene(scene_id, rs, gt_ls, pred_ls, aoi_polygons) return Scene(scene_id, rs, gt_ls, pred_ls)
def test_get_chip(self): # create a 3-channel raster from a 1-channel raster # using a ReclassTransformer to give each channel a different value # (100, 175, and 250 respectively) path = data_file_path('multi_raster_source/const_100_600x600.tiff') source_1 = RasterioSourceConfig(uris=[path], channel_order=[0]) source_2 = RasterioSourceConfig( uris=[path], channel_order=[0], transformers=[ReclassTransformerConfig(mapping={100: 175})]) source_3 = RasterioSourceConfig( uris=[path], channel_order=[0], transformers=[ReclassTransformerConfig(mapping={100: 250})]) cfg = MultiRasterSourceConfig(raster_sources=[ SubRasterSourceConfig(raster_source=source_1, target_channels=[0]), SubRasterSourceConfig(raster_source=source_2, target_channels=[1]), SubRasterSourceConfig(raster_source=source_3, target_channels=[2]) ], channel_order=[2, 1, 0], transformers=[ ReclassTransformerConfig(mapping={ 100: 10, 175: 17, 250: 25 }) ]) rs = cfg.build(tmp_dir=self.tmp_dir) with rs.activate(): window = Box(0, 0, 100, 100) # sub transformers and channel_order applied sub_chips = rs._get_sub_chips(window, raw=False) self.assertEqual(tuple(c.mean() for c in sub_chips), (100, 175, 250)) # sub transformers, channel_order, and transformer applied chip = rs.get_chip(window) self.assertEqual(tuple(chip.reshape(-1, 3).mean(axis=0)), (25, 17, 10)) # none of sub transformers, channel_order, and transformer applied sub_chips = rs._get_sub_chips(window, raw=True) self.assertEqual(tuple(c.mean() for c in sub_chips), (100, 100, 100)) chip = rs._get_chip(window) self.assertEqual(tuple(chip.reshape(-1, 3).mean(axis=0)), (100, 100, 100))
def get_valid_exp_builder(self): root_uri = '/some/dummy/root' img_path = '/dummy.tif' label_path = '/dummy.json' backend_conf_path = data_file_path( 'tf_object_detection/' 'embedded_ssd_mobilenet_v1_coco.config') pretrained_model = ('https://dummy.com/model.gz') task = self.get_test_task() backend = rv.BackendConfig.builder(rv.TF_OBJECT_DETECTION) \ .with_task(task) \ .with_template(backend_conf_path) \ .with_pretrained_model(pretrained_model) \ .with_train_options(sync_interval=None, do_monitoring=False) \ .build() raster_source = rv.RasterSourceConfig.builder(rv.GEOTIFF_SOURCE) \ .with_uri(img_path) \ .with_channel_order([0, 1, 2]) \ .with_stats_transformer() \ .build() scene = rv.SceneConfig.builder() \ .with_task(task) \ .with_id('od_test') \ .with_raster_source(raster_source) \ .with_label_source(label_path) \ .build() dataset = rv.DatasetConfig.builder() \ .with_train_scene(scene) \ .with_validation_scene(scene) \ .build() analyzer = rv.analyzer.StatsAnalyzerConfig() return rv.ExperimentConfig.builder() \ .with_id('object-detection-test') \ .with_root_uri(root_uri) \ .with_task(task) \ .with_backend(backend) \ .with_dataset(dataset) \ .with_analyzer(analyzer) \ .with_train_key('model_name')
def test_single_plugin_from_path(self): config = { 'PLUGINS_files': '["{}"]'.format(data_file_path('plugins/noop_augmentor.py')) } rv._registry.initialize_config(config_overrides=config) try: augmentor = rv.AugmentorConfig.builder('NOOP_AUGMENTOR') \ .build() \ .create_augmentor() self.assertIsInstance(augmentor, rv.augmentor.Augmentor) finally: # Reset config rv._registry.initialize_config()
def test_custom_default_model_config(self): model_defaults_path = data_file_path('custom-model-defaults.json') overrides = {'RV_model_defaults_uri': model_defaults_path} rv._registry.initialize_config(config_overrides=overrides) try: b = rv.BackendConfig.builder(rv.KERAS_CLASSIFICATION) \ .with_task(self.generate_task()) \ .with_model_defaults('CUSTOM_MODEL') \ .build() expected = 'https://www.azavea.com' self.assertEqual(b.pretrained_model_uri, expected) finally: # Reset the config. rv._registry.initialize_config()