resize_trilinear

paddle.fluid.layers.resize_trilinear(input, out_shape=None, scale=None, name=None, actual_shape=None, align_corners=True, align_mode=1, data_format='NCDHW')[source]

This op resizes the input by performing trilinear interpolation based on given output shape which specified by actual_shape, out_shape and scale in priority order.

Warning: the parameter actual_shape will be deprecated in the future and only use out_shape instead.

Trilinear interpolation is an extension of linear interpolation for interpolating functions of three variables (e.g. D-direction, H-direction and W-direction in this op) on a rectilinear 3D grid. The linear interpolation is performed on three directions.

For details of trilinear interpolation, please refer to Wikipedia: https://en.wikipedia.org/wiki/Trilinear_interpolation

Align_corners and align_mode are optinal parameters,the calculation method of interpolation can be selected by them.

Example:

For scale:

    if align_corners = True && out_size > 1 :

      scale_factor = (in_size-1.0)/(out_size-1.0)

    else:

      scale_factor = float(in_size/out_size)

Bilinear interpolation:

  if:

      align_corners = False , align_mode = 0

      input : (N,C,D_in,H_in,W_in)
      output: (N,C,D_out,H_out,W_out) where:

      D_out = (D_{in}+0.5) * scale_{factor} - 0.5
      H_out = (H_{in}+0.5) * scale_{factor} - 0.5
      W_out = (W_{in}+0.5) * scale_{factor} - 0.5

  else:

      input : (N,C,D_in,H_in,W_in)
      output: (N,C,D_out,H_out,W_out) where:

      D_out = D_{in} * scale_{factor}
      H_out = H_{in} * scale_{factor}
      W_out = W_{in} * scale_{factor}
Parameters
  • input (Variable) – 5-D Tensor, its data type is float32, float64, or uint8, its data format is specified by data_format.

  • out_shape (list|tuple|Variable|None) – The output shape of resized tensor, the shape is (out_d, out_h, out_w). Default: None. Every element should be an integer or a Tensor Variable with shape: [1] if it is a list. If it is a Tensor Variable, its dimension size should be 1.

  • scale (float|Variable|None) – The multiplier for the input depth, height or width. At least one of out_shape or scale must be set. And out_shape has a higher priority than scale. Default: None.

  • name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name

  • actual_shape (Variable) – An optional input to specify output shape dynamically. If provided, image resize according to this given shape rather than out_shape and scale specifying shape. That is to say actual_shape has the highest priority. It is recommended to use out_shape if you want to specify output shape dynamically, because actual_shape will be deprecated. When using actual_shape to specify output shape, one of out_shape and scale should also be set, otherwise errors would be occured in graph constructing stage. Default: None

  • align_corners (bool) – an optional bool. Defaults to True. If True, the centers of 4 corner pixels of the input and output tensors are aligned, preserving the values at the corner pixels, If False, are not aligned

  • align_mode (bool) – (int, default ‘1’), optional for bilinear interpolation, can be ‘0’ for src_idx = scale*(dst_indx+0.5)-0.5 , can be ‘1’ for src_idx = scale*dst_index

  • data_format (str, optional) – NCDHW(num_batches, channels, depth, height, width) or NDHWC(num_batches, depth, height, width, channels). Default: ‘NCDHW’.

Returns

A 5-D Tensor(NCDHW or NDHWC)

Return type

Variable

Examples

#declarative mode
import paddle.fluid as fluid
import numpy as np
input = fluid.data(name="input", shape=[None,3,6,8,10])

#1
output = fluid.layers.resize_trilinear(input=input,out_shape=[12,12,12])

#2
#x = np.array([2]).astype("int32")
#dim1 = fluid.data(name="dim1", shape=[1], dtype="int32")
#fluid.layers.assign(input=x, output=dim1)
#output = fluid.layers.resize_trilinear(input=input,out_shape=[12,dim1,4])

#3
#x = np.array([3,12,12]).astype("int32")
#shape_tensor = fluid.data(name="shape_tensor", shape=[3], dtype="int32")
#fluid.layers.assign(input=x, output=shape_tensor)
#output = fluid.layers.resize_trilinear(input=input,out_shape=shape_tensor)

#4
#x = np.array([0.5]).astype("float32")
#scale_tensor = fluid.data(name="scale", shape=[1], dtype="float32")
#fluid.layers.assign(x,scale_tensor)
#output = fluid.layers.resize_trilinear(input=input,scale=scale_tensor)

place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())

input_data = np.random.rand(2,3,6,8,10).astype("float32")

output_data = exe.run(fluid.default_main_program(),
    feed={"input":input_data},
    fetch_list=[output],
    return_numpy=True)

print(output_data[0].shape)

#1
# (2, 3, 12, 12, 12)
#2
# (2, 3, 12, 2, 4)
#3
# (2, 3, 3, 12, 12)
#4
# (2, 3, 3, 4, 5)

#imperative mode
import paddle.fluid.dygraph as dg

with dg.guard(place) as g:
    input = dg.to_variable(input_data)
    output = fluid.layers.resize_trilinear(input=input, out_shape=[12,12,12])
    print(output.shape)

    # [2L, 3L, 12L, 12L, 12L]