def upsampling(data, scale_h, scale_w, layout="NCHW", method='nearest_neighbor', align_corners=False): """Perform upsampling on the data. Nearest neighbor and bilinear upsampling are supported. Parameters ---------- inputs : tvm.Tensor inputs is a 4-D tensor with shape [batch, channel, in_height, in_width] or [batch, in_height, in_width, channel] scale_h : float Scaling factor for height scale_w : float Scaling factor for width layout : string, optional either "NCHW" or "NHWC" method : {"bilinear", "nearest_neighbor", "bicubic"} Method to be used for upsampling. Returns ------- output : tvm.Tensor 4-D with shape [batch, channel, in_height*scale_h, in_width*scale_w] or [batch, in_height*scale, in_width*scale, channel] """ base_layout = layout[0:4] if base_layout == "NCHW": out_shape = (simplify( topi.cast(tvm.round(data.shape[2] * scale_h), data.shape[2].dtype)), simplify( topi.cast(tvm.round(data.shape[3] * scale_w), data.shape[3].dtype))) elif layout == "NHWC": out_shape = (simplify( topi.cast(tvm.round(data.shape[1] * scale_h), data.shape[1].dtype)), simplify( topi.cast(tvm.round(data.shape[2] * scale_w), data.shape[2].dtype))) else: raise ValueError("not support this layout {} yet".format(layout)) coord_trans = "align_corners" if align_corners else "asymmetric" return topi.image.resize(data, out_shape, layout=layout, method=method, coordinate_transformation_mode=coord_trans)
def test_upsampling_infer_type(): n, c , h, w = tvm.var("n"), tvm.var("c"), tvm.var("h"), tvm.var("w") scale = tvm.const(2.0, "float64") x = relay.var("x", relay.TensorType((n, c, h, w), "float32")) y = relay.nn.upsampling(x, scale_h=2, scale_w=2, layout="NCHW", method="bilinear") "method=\"BINLINEAR\"" in y.astext() yy = run_infer_type(y) assert yy.checked_type == relay.TensorType((n, c, tvm.expr.Cast("int32", tvm.round(h*scale)), tvm.expr.Cast("int32", tvm.round(w*scale))), "float32") n, c = tvm.var("n"), tvm.var("c") x = relay.var("x", relay.TensorType((n, c, 100, 200), "float32")) y = relay.nn.upsampling(x, scale_h=2, scale_w=2, layout="NCHW", method="bilinear") yy = run_infer_type(y) assert yy.checked_type == relay.TensorType((n, c, 200, 400), "float32")
def _nearest_neighbor(*indices): n, c, y, x, cc = _get_indices(*indices) in_y = y_ratio * y in_x = x_ratio * x if align_corners: yint = tvm.round(in_y).astype('int32') xint = tvm.round(in_x).astype('int32') else: # Add epsilon to floor to prevent gpu rounding errors. epsilon = 1e-5 yint = tvm.floor(in_y + epsilon).astype('int32') xint = tvm.floor(in_x + epsilon).astype('int32') return _cast_output(_get_pixel(n, c, yint, xint, cc))
def test_upsampling3d_infer_type(): n, c, d, h, w = tvm.var("n"), tvm.var("c"), tvm.var("d"), tvm.var("h"), tvm.var("w") scale = tvm.const(2.0, "float64") x = relay.var("x", relay.TensorType((n, c, d, h, w), "float32")) y = relay.nn.upsampling3d(x, scale_d=2, scale_h=2, scale_w=2, layout="NCDHW", method="trilinear") yy = run_infer_type(y) assert yy.checked_type == relay.TensorType((n, c, tvm.expr.Cast("int32", tvm.round(d*scale)), tvm.expr.Cast("int32", tvm.round(h*scale)), tvm.expr.Cast("int32", tvm.round(w*scale))), "float32") n, c = tvm.var("n"), tvm.var("c") x = relay.var("x", relay.TensorType((n, c, 100, 100, 200), "float32")) y = relay.nn.upsampling3d(x, scale_d=2, scale_h=2, scale_w=2, layout="NCDHW", method="trilinear") yy = run_infer_type(y) assert yy.checked_type == relay.TensorType((n, c, 200, 200, 400), "float32")
def _pool(i, c, ph, pw): roi = rois[i] batch_index = roi[0].astype('int32') roi_start_w, roi_start_h, roi_end_w, roi_end_h = roi[1], roi[2], roi[ 3], roi[4] roi_start_h = tvm.round(roi_start_h * spatial_scale).astype('int32') roi_start_w = tvm.round(roi_start_w * spatial_scale).astype('int32') roi_end_h = tvm.round(roi_end_h * spatial_scale).astype('int32') roi_end_w = tvm.round(roi_end_w * spatial_scale).astype('int32') # force malformed ROIs to be 1x1 roi_h = tvm.max(roi_end_h - roi_start_h + 1, tvm.const(1, 'int32')) roi_w = tvm.max(roi_end_w - roi_start_w + 1, tvm.const(1, 'int32')) bin_h = roi_h.astype(dtype) / pooled_size_h bin_w = roi_w.astype(dtype) / pooled_size_w # use epsilon to prevent floating point precision loss in floor/ceil epsilon = tvm.const(0.00001, dtype) hstart = tvm.floor(ph * bin_h + epsilon).astype('int32') wstart = tvm.floor(pw * bin_w + epsilon).astype('int32') hend = tvm.ceil((ph + 1) * bin_h - epsilon).astype('int32') wend = tvm.ceil((pw + 1) * bin_w - epsilon).astype('int32') hstart = tvm.min(tvm.max(hstart + roi_start_h, 0), height) wstart = tvm.min(tvm.max(wstart + roi_start_w, 0), width) hend = tvm.min(tvm.max(hend + roi_start_h, 0), height) wend = tvm.min(tvm.max(wend + roi_start_w, 0), width) non_empty = tvm.all(hstart < hend, wstart < wend) min_value = lambda dtype: tvm.if_then_else( non_empty, tvm.min_value(dtype), tvm.const(0.0, dtype)) # pylint: disable=unnecessary-lambda _max = tvm.comm_reducer(lambda x, y: tvm.make._OpMax(x, y), min_value, name='max') rh = tvm.reduce_axis((0, hend - hstart), 'rh') rw = tvm.reduce_axis((0, wend - wstart), 'rw') return _max(data[batch_index, c, hstart + rh, wstart + rw], axis=[rh, rw])
def _nearest_neighbor(*indices): n, c, z, y, x, cc = _get_indices(*indices) in_z = z_ratio * z in_y = y_ratio * y in_x = x_ratio * x if coordinate_transformation_mode == "align_corners": zint = tvm.round(in_z).astype('int32') yint = tvm.round(in_y).astype('int32') xint = tvm.round(in_x).astype('int32') elif coordinate_transformation_mode in ["asymmetric", "half_pixel"]: # Add epsilon to floor to prevent gpu rounding errors. epsilon = 1e-5 zint = tvm.floor(in_z + epsilon).astype('int32') yint = tvm.floor(in_y + epsilon).astype('int32') xint = tvm.floor(in_x + epsilon).astype('int32') else: raise ValueError("Unsupported coordinate_transformation_mode: {}".format( coordinate_transformation_mode)) return _cast_output(_get_pixel(n, c, zint, yint, xint, cc))
def round(x): """Round elements of x to nearest integer. Parameters ---------- x : tvm.Tensor Input argument. Returns ------- y : tvm.Tensor The result. """ return tvm.compute(x.shape, lambda *i: tvm.round(x(*i)))
def test_const_propagation(): x1 = tvm.const(4, "int32") x2 = x1 + 5 assert isinstance(x2, tvm.expr.IntImm) and x2.value == 9 x3 = x2 / 3 assert isinstance(x3, tvm.expr.IntImm) and x3.value == 3 x4 = x3 + 0.5 assert isinstance(x4, tvm.expr.FloatImm) and x4.value == 3.5 x5 = tvm.ceil(x4) assert isinstance(x5, tvm.expr.FloatImm) and x5.value == 4 x6 = x5.astype('int') assert isinstance(x6, tvm.expr.IntImm) and x6.value == 4 y = (tvm.round((tvm.const(6.5, 'float32') - 1) / 1.5) + 2).astype('int') assert isinstance(y, tvm.expr.IntImm) and y.value == 6
def test_const_fold4(): x1 = tvm.const(4, "int32") x2 = x1 + 5 assert isinstance(x2, tvm.expr.IntImm) and x2.value == 9 x3 = x2 / 3 assert isinstance(x3, tvm.expr.IntImm) and x3.value == 3 x4 = x3 + 0.55 assert isinstance(x4, tvm.expr.FloatImm) and abs(x4.value - 3.55) < 1e-6 x5 = tvm.ceil(x4) assert isinstance(x5, tvm.expr.FloatImm) and x5.value == 4 x6 = x5.astype('int') assert isinstance(x6, tvm.expr.IntImm) and x6.value == 4, "x6={}".format(x6) y = (tvm.round((tvm.const(6.5, 'float32') - 1) / 1.5) + 2).astype('int') assert isinstance(y, tvm.expr.IntImm) and y.value == 6
def resize_nearest_neighbor(indices, data, image_height, image_width, target_height, target_width, boxes=None, box_indices=None, extrapolation_value=None, layout='NCHW', coordinate_transformation_mode="align_corners", out_dtype=None): """Perform resize operation with nearest neighbor method on the data. For details about Nearest-neighbor interpolation please refer to https://en.wikipedia.org/wiki/Nearest-neighbor_interpolation. Parameters ---------- indices : tuple The indices of input data data : tvm.Tensor inputs is a 4-D tensor with shape [batch, channel, in_height, in_width] or [batch, in_height, in_width, channel] image_height : integer Input image height image_width : integer Input image width target_height : integer The target resized image height target_width : integer The target resized image width boxes : tvm.Tensor, optional A 2-D tensor of shape [num_boxes, 4]. Each row of the tensor specifies the coordinates of a box. box_indices : tvm.Tensor, optional A 1-D tensor of shape [num_boxes], box_indices[i] specifies the data that the i-th box refers to. extrapolation_value: float, optional Value used for extrapolation, when applicable. layout: string, optional "NCHW", "NHWC", or "NCHWc". coordinate_transformation_mode: string, optional Describes how to transform the coordinate in the resized tensor to the coordinate in the original tensor. Refer to the ONNX Resize operator specification for details. Available options are "half_pixel", "align_corners" and "asymmetric". out_dtype: string, optional Type to return. If left None will be same as input type. Returns ------- output : out_dtype The computed result with type out_dtype """ def _cast_output(value, data_dtype="float32", out_dtype=None): if out_dtype: dtype = out_dtype else: dtype = data_dtype return value.astype(dtype) def _get_indices(indices, layout='NCHW'): if layout == 'NHWC': n, y, x, c = indices cc = None elif layout == 'NCHW': n, c, y, x = indices cc = None else: n, c, y, x, cc = indices return n, c, y, x, cc def _get_pixel(data, layout, n, c, y, x, cc): if boxes is None: y = tvm.max(tvm.min(y, image_height - 1), 0) x = tvm.max(tvm.min(x, image_width - 1), 0) if layout == 'NHWC': return data(n, y, x, c).astype('float') if layout == 'NCHW': return data(n, c, y, x).astype('float') # else must be NCHWxc return data(n, c, y, x, cc).astype('float') n, c, y, x, cc = _get_indices(indices, layout) box_idx = box_indices(n) if box_indices is not None else n if boxes is not None: y1, x1 = boxes(n, 0), boxes(n, 1) y2, x2 = boxes(n, 2), boxes(n, 3) in_h = (image_height - 1) * (y2 - y1) in_w = (image_width - 1) * (x2 - x1) h_scale = in_h.astype('float') / (target_height - 1) w_scale = in_w.astype('float') / (target_width - 1) in_y = y1 * (image_height - 1) + h_scale * y in_x = x1 * (image_width - 1) + w_scale * x else: if coordinate_transformation_mode == "align_corners": h_scale = (image_height - 1).astype('float') / (target_height - 1) w_scale = (image_width - 1).astype('float') / (target_width - 1) elif coordinate_transformation_mode in ["asymmetric", "half_pixel"]: h_scale = image_height.astype('float') / target_height w_scale = image_width.astype('float') / target_width else: raise ValueError("Unsupported coordinate_transformation_mode: {}".format( coordinate_transformation_mode)) in_y = h_scale * y in_x = w_scale * x if coordinate_transformation_mode == "align_corners" or boxes is not None: closest_x_index = tvm.round(in_x).astype("int32") closest_y_index = tvm.round(in_y).astype("int32") else: # Add epsilon to floor to prevent gpu rounding errors. epsilon = 1e-5 closest_y_index = tvm.floor(in_y + epsilon).astype('int32') closest_x_index = tvm.floor(in_x + epsilon).astype('int32') value = _get_pixel(data, layout, box_idx, c, closest_y_index, closest_x_index, cc) if extrapolation_value is not None: out = tvm.if_then_else(in_y < 0, extrapolation_value, tvm.if_then_else(in_y > image_height - 1, extrapolation_value, value)) # use extrapolation_value if in_x is out of boundary value = tvm.if_then_else(in_x < 0, extrapolation_value, tvm.if_then_else(in_x > image_width - 1, extrapolation_value, out)) return _cast_output(value, data.dtype, out_dtype=out_dtype)
def upsampling3d(data, scale_d, scale_h, scale_w, layout="NCDHW", method='nearest_neighbor', coordinate_transformation_mode="half_pixel"): """Perform upsampling on the data. Nearest neighbor and bilinear upsampling are supported. Parameters ---------- inputs : tvm.Tensor inputs is a 5-D tensor with shape [batch, channel, in_depth, in_height, in_width] or [batch, in_depth, in_height, in_width, channel] scale_d : float Scaling factor for depth scale_h : float Scaling factor for height scale_w : float Scaling factor for width layout : string, optional either "NCDHW" or "NDHWC" method : {"trilinear", "nearest_neighbor"} Method to be used for upsampling. coordinate_transformation_mode: string, optional Describes how to transform the coordinate in the resized tensor to the coordinate in the original tensor. Refer to the ONNX Resize operator specification for details. Available options are "half_pixel", "align_corners" and "asymmetric". Returns ------- output : tvm.Tensor 5-D with shape [batch, channel, in_depth*scale, in_height*scale, in_width*scale] or [batch, in_depth*scale, in_height*scale, in_width*scale, channel] """ base_layout = layout[0:5] if base_layout == "NCDHW": out_shape = (simplify( topi.cast(tvm.round(data.shape[2] * scale_d), data.shape[2].dtype)), simplify( topi.cast(tvm.round(data.shape[3] * scale_h), data.shape[3].dtype)), simplify( topi.cast(tvm.round(data.shape[4] * scale_w), data.shape[4].dtype))) elif layout == "NDHWC": out_shape = (simplify( topi.cast(tvm.round(data.shape[1] * scale_d), data.shape[1].dtype)), simplify( topi.cast(tvm.round(data.shape[2] * scale_h), data.shape[2].dtype)), simplify( topi.cast(tvm.round(data.shape[3] * scale_w), data.shape[3].dtype))) else: raise ValueError("not support this layout {} yet".format(layout)) return topi.image.resize3d( data, out_shape, layout=layout, method=method, coordinate_transformation_mode=coordinate_transformation_mode)