# 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:  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 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().astype("int32")
#dim1 = fluid.data(name="dim1", shape=, 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=, 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=, 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.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