image_resize

paddle.fluid.layers.nn. image_resize ( input, out_shape=None, scale=None, name=None, resample='BILINEAR', actual_shape=None, align_corners=True, align_mode=1, data_format='NCHW' ) [source]

This op resizes a batch of images.

The input must be a 3-D Tensor of the shape (num_batches, channels, in_w) or a 4-D Tensor of the shape (num_batches, channels, in_h, in_w) or (num_batches, in_h, in_w, channels), or a 5-D Tensor of the shape (num_batches, channels, in_d, in_h, in_w) or (num_batches, in_d, in_h, in_w, channels), and the resizing only applies on the three dimensions(depth, height and width).

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

Supporting resample methods:

‘LINEAR’ : Linear interpolation

‘BILINEAR’ : Bilinear interpolation

‘TRILINEAR’ : Trilinear interpolation

‘NEAREST’ : Nearest neighbor interpolation

‘BICUBIC’ : Bicubic interpolation

Linear interpolation is the method of using a line connecting two known quantities to determine the value of an unknown quantity between the two known quantities.

Nearest neighbor interpolation is to perform nearest neighbor interpolation in both the 3rd dimension(in height direction) and the 4th dimension(in width direction) on input tensor.

Bilinear interpolation is an extension of linear interpolation for interpolating functions of two variables (e.g. H-direction and W-direction in this op) on a rectilinear 2D grid. The key idea is to perform linear interpolation first in one direction, and then again in the other direction.

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.

Bicubic interpolation is an extension of cubic interpolation for interpolating data points on a two-dimensional regular grid. The interpolated surface is smoother than corresponding surfaces obtained by bilinear interpolation or nearest-neighbor interpolation.

Align_corners and align_mode are optional 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)


Nearest neighbor interpolation:

  if:
      align_corners = False

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

      H_out = floor (H_{in} * scale_{factor})
      W_out = floor (W_{in} * scale_{factor})

  else:
      align_corners = True

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

      H_out = round(H_{in} * scale_{factor})
      W_out = round(W_{in} * scale_{factor})

linear interpolation:

  if:
      align_corners = False , align_mode = 0

      input : (N,C,W_in)
      output: (N,C,W_out) where:

      W_out = (W_{in}+0.5) * scale_{factor} - 0.5

  else:

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

      W_out = W_{in} * scale_{factor}

Bilinear interpolation:

  if:
      align_corners = False , align_mode = 0

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

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

  else:

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

      H_out = H_{in} * scale_{factor}
      W_out = W_{in} * scale_{factor}

Trilinear 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}

Trilinear 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}

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

For details of nearest neighbor interpolation, please refer to Wikipedia: https://en.wikipedia.org/wiki/Nearest-neighbor_interpolation.

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

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

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

Parameters

  • input (Variable) – 3-D, 4-D or 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) – Output shape of image resize layer, the shape is (out_w, ) when input is a 3-D Tensor, the shape is (out_h, out_w) when input is a 4-D Tensor and is (out_d, out_h, out_w) when input is a 5-D Tensor. Default: None. If a list, each element can be an integer or a Tensor Variable of shape: [1]. If a Tensor Variable, its dimensions size should be a 1.

  • scale (float|Variable|None) – The multiplier for the input 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|None) – A name for this layer(optional). If set None, the layer will be named automatically.

  • resample (str) – The resample method. It supports ‘LINEAR’, ‘BICUBIC’, ‘BILINEAR’, ‘TRILINEAR’ and ‘NEAREST’ currently. Default: ‘BILINEAR’

  • 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 occurred in graph constructing stage. Default: None

  • align_corners (bool) – An optional bool, If True, the centers of the 4 corner pixels of the input and output tensors are aligned, preserving the values at the corner pixels. Default: True

  • align_mode (int) – An optional for linear/bilinear/trilinear interpolation. Refer to the fomula in the the example code above, it 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) – Specify the data format of the input, and the data format of the output will be consistent with that of the input. An optional string from:NCW, NWC, “NCHW”, “NHWC”, “NCDHW”, “NDHWC”. The default is “NCHW”. When it is “NCHW”, the data is stored in the order of: [batch_size, input_channels, input_height, input_width]. When it is “NCHW”, the data is stored in the order of: [batch_size, input_channels, input_depth, input_height, input_width].

Returns

A 3-D Tensor of the shape (num_batches, channels, out_w) or (num_batches, out_w, channels), A 4-D Tensor of the shape (num_batches, channels, out_h, out_w) or (num_batches, out_h, out_w, channels), or 5-D Tensor of the shape (num_batches, channels, out_d, out_h, out_w) or (num_batches, out_d, out_h, out_w, channels).

Raises

  • TypeError – out_shape should be a list or tuple or Variable.

  • TypeError – actual_shape should either be Variable or None.

  • ValueError – The ‘resample’ of image_resize can only be ‘LINEAR’, ‘BILINEAR’, ‘TRILINEAR’, ‘BICUBIC’ or ‘NEAREST’ currently.

  • ValueError – ‘LINEAR’ only support 3-D tensor.

  • ValueError – ‘BICUBIC’, ‘BILINEAR’ and ‘NEAREST’ only support 4-D tensor.

  • ValueError – ‘TRILINEAR’ only support 5-D tensor.

  • ValueError – One of out_shape and scale must not be None.

  • ValueError – out_shape length should be 1 for input 3-D tensor.

  • ValueError – out_shape length should be 2 for input 4-D tensor.

  • ValueError – out_shape length should be 3 for input 5-D tensor.

  • ValueError – scale should be greater than zero.

  • TypeError – align_corners should be a bool value

  • ValueError – align_mode can only be ‘0’ or ‘1’

  • ValueError – data_format can only be ‘NCW’, ‘NWC’, ‘NCHW’, ‘NHWC’, ‘NCDHW’ or ‘NDHWC’.

Examples

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

#1
output = fluid.layers.image_resize(input=input,out_shape=[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.image_resize(input=input,out_shape=[12,dim1])

#3
#x = np.array([3,12]).astype("int32")
#shape_tensor = fluid.data(name="shape_tensor", shape=[2], dtype="int32")
#fluid.layers.assign(input=x, output=shape_tensor)
#output = fluid.layers.image_resize(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.image_resize(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,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)
#2
# (2, 3, 12, 2)
#3
# (2, 3, 3, 12)
#4
# (2, 3, 3, 5)

#imperative mode
import paddle.fluid.dygraph as dg

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

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