コード例 #1
0
def create_coco_pipeline(file_root,
                         annotations_file,
                         batch_size=1,
                         device_id=0,
                         num_threads=4,
                         local_rank=0,
                         world_size=1):
    pipeline = Pipeline(batch_size, num_threads,
                        local_rank, seed=42 + device_id)

    with pipeline:
        images, bboxes, labels = fn.coco_reader(file_root=file_root,
                                                annotations_file=annotations_file,
                                                skip_empty=True,
                                                shard_id=local_rank,
                                                num_shards=world_size,
                                                ratio=True,
                                                ltrb=True,
                                                random_shuffle=False,
                                                shuffle_after_epoch=True,
                                                name="Reader")

        crop_begin, crop_size, bboxes, labels = fn.random_bbox_crop(bboxes, labels,
                                                                    device="cpu",
                                                                    aspect_ratio=[0.5, 2.0],
                                                                    thresholds=[0, 0.1, 0.3, 0.5, 0.7, 0.9],
                                                                    scaling=[0.3, 1.0],
                                                                    bbox_layout="xyXY",
                                                                    allow_no_crop=True,
                                                                    num_attempts=50)
        images = fn.image_decoder_slice(images, crop_begin, crop_size, device="mixed", output_type=types.RGB)
        flip_coin = fn.coin_flip(probability=0.5)
        images = fn.resize(images,
                           resize_x=300,
                           resize_y=300,
                           min_filter=types.DALIInterpType.INTERP_TRIANGULAR)

        # use float to avoid clipping and quantizing the intermediate result
        images = fn.hsv(images, dtype=types.FLOAT, hue=fn.uniform(range=[-0.5, 0.5]),
                        saturation=fn.uniform(range=[0.5, 1.5]))

        images = fn.brightness_contrast(images,
                                        contrast_center = 128,  # input is in float, but in 0..255 range
                                        dtype = types.UINT8,
                                        brightness = fn.uniform(range=[0.875, 1.125]),
                                        contrast = fn.uniform(range=[0.5, 1.5]))

        bboxes = fn.bb_flip(bboxes, ltrb=True, horizontal=flip_coin)
        images = fn.crop_mirror_normalize(images,
                                          mean=[104., 117., 123.],
                                          std=[1., 1., 1.],
                                          mirror=flip_coin,
                                          dtype=types.FLOAT,
                                          output_layout="CHW",
                                          pad_output=False)

        pipeline.set_outputs(images, bboxes, labels)
    return pipeline
コード例 #2
0
 def image_decoder_slice_pipe(max_batch_size, input_data, device):
     pipe = Pipeline(batch_size=max_batch_size, num_threads=4, device_id=0)
     encoded = fn.external_source(source=input_data,
                                  cycle=False,
                                  device='cpu')
     anch = fn.constant(fdata=.1)
     sh = fn.constant(fdata=.4)
     decoded = fn.image_decoder_slice(encoded,
                                      anch,
                                      sh,
                                      axes=0,
                                      device=device)
     pipe.set_outputs(decoded)
     return pipe
コード例 #3
0
ファイル: test_dali_cpu_only.py プロジェクト: hephaex/DALI
def test_image_decoder_slice_cpu():
    anch_shape = [1, 2]

    def get_anchors():
        out = [(np.random.randint(1, 128, size=anch_shape, dtype=np.uint8) /
                255).astype(dtype=np.float32) for _ in range(batch_size)]
        return out

    def get_shape():
        out = [(np.random.randint(1, 128, size=anch_shape, dtype=np.uint8) /
                255).astype(dtype=np.float32) for _ in range(batch_size)]
        return out

    pipe = Pipeline(batch_size=batch_size, num_threads=4, device_id=None)
    input, _ = fn.file_reader(file_root=images_dir, shard_id=0, num_shards=1)
    anchors = fn.external_source(source=get_anchors)
    shape = fn.external_source(source=get_shape)
    processed = fn.image_decoder_slice(input, anchors, shape)
    pipe.set_outputs(processed)
    pipe.build()
    for _ in range(3):
        pipe.run()
コード例 #4
0
ファイル: coco_pipeline.py プロジェクト: xvdp/DALI
def create_coco_pipeline(default_boxes, args):
    try:
        shard_id = torch.distributed.get_rank()
        num_shards = torch.distributed.get_world_size()
    except RuntimeError:
        shard_id = 0
        num_shards = 1

    images, bboxes, labels = fn.readers.coco(
        file_root=args.train_coco_root,
        annotations_file=args.train_annotate,
        skip_empty=True,
        shard_id=shard_id,
        num_shards=num_shards,
        ratio=True,
        ltrb=True,
        random_shuffle=False,
        shuffle_after_epoch=True,
        name="Reader")

    crop_begin, crop_size, bboxes, labels = fn.random_bbox_crop(
        bboxes,
        labels,
        device="cpu",
        aspect_ratio=[0.5, 2.0],
        thresholds=[0, 0.1, 0.3, 0.5, 0.7, 0.9],
        scaling=[0.3, 1.0],
        bbox_layout="xyXY",
        allow_no_crop=True,
        num_attempts=50)
    images = fn.image_decoder_slice(images,
                                    crop_begin,
                                    crop_size,
                                    device="mixed",
                                    output_type=types.RGB)
    flip_coin = fn.random.coin_flip(probability=0.5)
    images = fn.resize(images,
                       resize_x=300,
                       resize_y=300,
                       min_filter=types.DALIInterpType.INTERP_TRIANGULAR)

    saturation = fn.uniform(range=[0.5, 1.5])
    contrast = fn.uniform(range=[0.5, 1.5])
    brightness = fn.uniform(range=[0.875, 1.125])
    hue = fn.uniform(range=[-0.5, 0.5])

    images = fn.hsv(images, dtype=types.FLOAT, hue=hue,
                    saturation=saturation)  # use float to avoid clipping and
    # quantizing the intermediate result
    images = fn.brightness_contrast(
        images,
        contrast_center=128,  # input is in float, but in 0..255 range
        dtype=types.UINT8,
        brightness=brightness,
        contrast=contrast)

    dtype = types.FLOAT16 if args.fp16 else types.FLOAT

    bboxes = fn.bb_flip(bboxes, ltrb=True, horizontal=flip_coin)
    images = fn.crop_mirror_normalize(
        images,
        crop=(300, 300),
        mean=[0.485 * 255, 0.456 * 255, 0.406 * 255],
        std=[0.229 * 255, 0.224 * 255, 0.225 * 255],
        mirror=flip_coin,
        dtype=dtype,
        output_layout="CHW",
        pad_output=False)

    bboxes, labels = fn.box_encoder(bboxes,
                                    labels,
                                    criteria=0.5,
                                    anchors=default_boxes.as_ltrb_list())

    labels = labels.gpu()
    bboxes = bboxes.gpu()

    return images, bboxes, labels
コード例 #5
0
def check_bbox_random_crop_adjust_polygons(file_root,
                                           annotations_file,
                                           batch_size=3,
                                           num_iters=4,
                                           num_threads=4,
                                           device_id=0,
                                           seed=1234):
    pipe = Pipeline(batch_size=batch_size,
                    num_threads=num_threads,
                    device_id=device_id,
                    seed=seed)
    with pipe:
        # Read data from COCO
        # ratio=True means both bboxes and masks coordinates will be relative to the image dimensions (range [0.0, 1.0])
        inputs, in_bboxes, labels, in_polygons, in_vertices = \
            fn.readers.coco(
                file_root=file_root, annotations_file=annotations_file, shard_id=0, num_shards=1,
                ratio=True, ltrb=True, polygon_masks=True
            )

        # Generate a random crop. out_bboxes are adjusted to the crop window
        slice_anchor, slice_shape, out_bboxes, labels, bbox_indices = \
            fn.random_bbox_crop(
                in_bboxes, labels,
                aspect_ratio=[0.5, 2.0], thresholds=[0, 0.1, 0.3, 0.5, 0.7, 0.9],
                scaling=[0.3, 1.0], bbox_layout='xyXY', output_bbox_indices=True
            )
        # Crop the image
        images = fn.image_decoder_slice(inputs,
                                        slice_anchor,
                                        slice_shape,
                                        device='mixed',
                                        axis_names='WH')

        sel_polygons, sel_vertices = fn.segmentation.select_masks(
            bbox_indices, in_polygons, in_vertices)

        # Adjust masks coordinates to the coordinate space of the cropped image
        MT = fn.transforms.crop(from_start=slice_anchor,
                                from_end=(slice_anchor + slice_shape))
        out_vertices = fn.coord_transform(sel_vertices, MT=MT)

        # Converting to absolute coordinates (demo purposes)
        image_shape = fn.peek_image_shape(inputs, type=types.FLOAT)
        h = fn.slice(image_shape, 0, 1, axes=[0])
        w = fn.slice(image_shape, 1, 1, axes=[0])

        # Original bboxes
        bbox_x = fn.slice(in_bboxes, 0, 1, axes=[1])
        bbox_y = fn.slice(in_bboxes, 1, 1, axes=[1])
        bbox_X = fn.slice(in_bboxes, 2, 1, axes=[1])
        bbox_Y = fn.slice(in_bboxes, 3, 1, axes=[1])
        in_bboxes_abs = fn.cat(bbox_x * w,
                               bbox_y * h,
                               bbox_X * w,
                               bbox_Y * h,
                               axis=1)

        # Transform to convert relative coordinates to absolute
        scale_rel_to_abs = fn.transforms.scale(scale=fn.cat(w, h))

        # Selected vertices (relative coordinates)
        sel_vertices_abs = fn.coord_transform(out_vertices,
                                              MT=scale_rel_to_abs)

        # Output bboxes
        bbox2_x = fn.slice(out_bboxes, 0, 1, axes=[1])
        bbox2_y = fn.slice(out_bboxes, 1, 1, axes=[1])
        bbox2_X = fn.slice(out_bboxes, 2, 1, axes=[1])
        bbox2_Y = fn.slice(out_bboxes, 3, 1, axes=[1])
        out_bboxes_abs = fn.cat(bbox2_x * w,
                                bbox2_y * h,
                                bbox2_X * w,
                                bbox2_Y * h,
                                axis=1)

        # Output vertices (absolute coordinates)
        out_vertices_abs = fn.coord_transform(out_vertices,
                                              MT=scale_rel_to_abs)

        # Clamped coordinates
        out_vertices_clamped = math.clamp(out_vertices, 0.0, 1.0)
        out_vertices_clamped_abs = fn.coord_transform(out_vertices_clamped,
                                                      MT=scale_rel_to_abs)

    pipe.set_outputs(in_vertices, sel_vertices, sel_vertices_abs, out_vertices,
                     out_vertices_clamped, out_vertices_abs,
                     out_vertices_clamped_abs, in_bboxes, in_bboxes_abs,
                     out_bboxes, out_bboxes_abs, in_polygons, sel_polygons,
                     image_shape, slice_anchor, slice_shape, bbox_indices)
    pipe.build()
    for i in range(
            num_iters
    ):  # Enough iterations to see an example with more than one bounding box
        outs = pipe.run()
        for j in range(batch_size):
            in_vertices, sel_vertices, sel_vertices_abs, \
                out_vertices, out_vertices_clamped, out_vertices_abs, out_vertices_clamped_abs, \
                in_bboxes, in_bboxes_abs, out_bboxes, out_bboxes_abs, \
                in_polygons, sel_polygons, \
                image_shape, slice_anchor, slice_shape, bbox_indices = \
                (outs[k].at(j) for k in range(len(outs)))

            # Checking that the output polygon descriptors are the ones associated with the
            # selected bounding boxes
            expected_polygons_list = []
            expected_vertices_list = []
            ver_count = 0
            for k in range(in_polygons.shape[0]):
                mask_id = in_polygons[k][0]
                in_ver_start_idx = in_polygons[k][1]
                in_ver_end_idx = in_polygons[k][2]
                pol_nver = in_ver_end_idx - in_ver_start_idx
                if mask_id in bbox_indices:
                    expected_polygons_list.append(
                        [mask_id, ver_count, ver_count + pol_nver])
                    for j in range(in_ver_start_idx, in_ver_end_idx):
                        expected_vertices_list.append(in_vertices[j])
                    ver_count = ver_count + pol_nver
            expected_sel_polygons = np.array(expected_polygons_list)
            np.testing.assert_equal(expected_sel_polygons, sel_polygons)

            # Checking the selected vertices correspond to the selected masks
            expected_sel_vertices = np.array(expected_vertices_list)
            np.testing.assert_equal(expected_sel_vertices, sel_vertices)

            # Chekc that the vertices are correctly mapped to the cropping window
            expected_out_vertices = np.copy(expected_sel_vertices)
            crop_x, crop_y = slice_anchor
            crop_w, crop_h = slice_shape
            for v in range(expected_out_vertices.shape[0]):
                expected_out_vertices[v, 0] = (expected_out_vertices[v, 0] -
                                               crop_x) / crop_w
                expected_out_vertices[v, 1] = (expected_out_vertices[v, 1] -
                                               crop_y) / crop_h
            np.testing.assert_allclose(expected_out_vertices,
                                       out_vertices,
                                       rtol=1e-4)

            # Checking the conversion to absolute coordinates
            h, w, c = image_shape
            expected_out_vertices_abs = np.copy(expected_out_vertices)
            for v in range(expected_out_vertices_abs.shape[0]):
                expected_out_vertices_abs[v,
                                          0] = expected_out_vertices[v, 0] * w
                expected_out_vertices_abs[v,
                                          1] = expected_out_vertices[v, 1] * h
            np.testing.assert_allclose(expected_out_vertices_abs,
                                       out_vertices_abs,
                                       rtol=1e-4)

            # Checking clamping of the relative coordinates
            expected_out_vertices_clamped = np.copy(expected_out_vertices)
            np.clip(expected_out_vertices_clamped, a_min=0.0, a_max=1.0)
            np.testing.assert_allclose(expected_out_vertices_clamped,
                                       out_vertices,
                                       rtol=1e-4)

            # Checking clamping of the absolute coordinates
            expected_out_vertices_clamped_abs = np.copy(
                expected_out_vertices_abs)
            for v in range(expected_out_vertices_clamped_abs.shape[0]):
                expected_out_vertices_clamped_abs[v, 0] = np.clip(
                    expected_out_vertices_abs[v, 0], a_min=0, a_max=w)
                expected_out_vertices_clamped_abs[v, 1] = np.clip(
                    expected_out_vertices_abs[v, 1], a_min=0, a_max=h)
            np.testing.assert_allclose(expected_out_vertices_clamped_abs,
                                       out_vertices_clamped_abs,
                                       rtol=1e-4)

            # Checking scaling of the bounding boxes
            expected_in_bboxes_abs = np.copy(in_bboxes)
            for v in range(expected_in_bboxes_abs.shape[0]):
                expected_in_bboxes_abs[v, 0] = expected_in_bboxes_abs[v, 0] * w
                expected_in_bboxes_abs[v, 1] = expected_in_bboxes_abs[v, 1] * h
                expected_in_bboxes_abs[v, 2] = expected_in_bboxes_abs[v, 2] * w
                expected_in_bboxes_abs[v, 3] = expected_in_bboxes_abs[v, 3] * h
            np.testing.assert_allclose(expected_in_bboxes_abs,
                                       in_bboxes_abs,
                                       rtol=1e-4)

            # Check box selection and mapping to the cropping window
            expected_out_bboxes = np.copy(in_bboxes[bbox_indices, :])
            for k in range(expected_out_bboxes.shape[0]):
                expected_out_bboxes[k, 0] = (expected_out_bboxes[k, 0] -
                                             crop_x) / crop_w
                expected_out_bboxes[k, 1] = (expected_out_bboxes[k, 1] -
                                             crop_y) / crop_h
                expected_out_bboxes[k, 2] = (expected_out_bboxes[k, 2] -
                                             crop_x) / crop_w
                expected_out_bboxes[k, 3] = (expected_out_bboxes[k, 3] -
                                             crop_y) / crop_h
            expected_out_bboxes = np.clip(expected_out_bboxes,
                                          a_min=0.0,
                                          a_max=1.0)
            np.testing.assert_allclose(expected_out_bboxes,
                                       out_bboxes,
                                       rtol=1e-4)

            expected_out_bboxes_abs = np.copy(expected_out_bboxes)
            expected_out_bboxes_abs[:, 0] = expected_out_bboxes_abs[:, 0] * w
            expected_out_bboxes_abs[:, 1] = expected_out_bboxes_abs[:, 1] * h
            expected_out_bboxes_abs[:, 2] = expected_out_bboxes_abs[:, 2] * w
            expected_out_bboxes_abs[:, 3] = expected_out_bboxes_abs[:, 3] * h
            np.testing.assert_allclose(expected_out_bboxes_abs,
                                       out_bboxes_abs,
                                       rtol=1e-4)