[object Object]

[object Object][object Object]undefined[object Object]

• API description: Applies the trilinear interpolation algorithm to upsample the input signal composed of several input channels.
• Formulas:
  • Core algorithm logic:
    1. Each point in the target image is mapped back to the original image to obtain a coordinate with a decimal point.
    2. Based on the floating-point coordinate, the points of the original images before and after the target image are calculated.
    3. Calculate the weights from the adjacent points to the target points, and multiply and accumulate the weights to obtain the target point values.
  • Calculation logic: An image can be scaled by corner alignment (that is, based on the center point of the pixels in the upper left corner of the source image) or edge alignment (that is, based on the vertex in the upper left corner and two edges of the source image). The two modes differ in the scaling factor and coordinates. For a three-dimensional interpolation point (N, C, D, H, W), the following formula is used:$$scale\_d =\begin{cases} (self.dim[2]-1) / (outputSize[0]-1) & alignCorners=true \\ 1 / scales\_d & alignCorners=false\&scales\_d>0\\ self.dim[2] / outputSize[0] & alignCorners=false \end{cases}$$ $$scale\_h =\begin{cases} (self.dim[3]-1) / (outputSize[1]-1) & alignCorners=true \\ 1 / scales\_h & alignCorners=false\&scales\_h>0\\ self.dim[3] / outputSize[1] & alignCorners=false \end{cases}$$ $$scale\_w =\begin{cases} (self.dim[4]-1) / (outputSize[2]-1) & alignCorners=true \\ 1 / scales\_w & alignCorners=false\&scales\_w>0\\ self.dim[4] / outputSize[2] & alignCorners=false \end{cases}$$ Therefore, for a point p (x, y, z) in a direction of the output, a point mapped back to the source image is denoted as q (x', y', z'). Then:$$x' =\begin{cases} x * scale\_d & alignCorners=true \\ MAX(0,{(x+0.5)*scale\_d-0.5}) & alignCorners=false \end{cases}$$ $$y' =\begin{cases} y * scale\_h & alignCorners=true \\ MAX(0,{(y+0.5)*scale\_h-0.5}) & alignCorners=false \end{cases}$$ $$z' =\begin{cases} z * scale\_w & alignCorners=true \\ MAX(0,{(z+0.5)*scale\_w-0.5}) & alignCorners=false \end{cases}$$

    • Denoted:

      $$x_{0} =int(x'),x_{1} =int(x')+1, lambda_{0} = x_{1}-x', lambda_{1} = 1-lambda_{0}$$ $$y_{0} =int(y'),y_{1} =int(y')+1, lambdb_{0} = y_{1}-y', lambdb_{1} = 1-lambdb_{0}$$ $$z_{0} =int(z'),z_{1} =int(z')+1, lambdc_{0} = z_{1}-z', lambdc_{1} = 1-lambdc_{0}$$

    • Then:

      $${V(p_{x, y, z})} = {V(p_{x0, y0, z0})} * {lambda_{0}} * {lambdb_{0}} * {lambdc_{0}} + {V(p_{x0, y0, z1})} * {lambda_{0}} * {lambdb_{0}} * {lambdc_{1}} + {V(p_{x0, y1, z0})} * {lambda_{0}} * {lambdb_{1}} * {lambdc_{0}} + {V(p_{x0, y1, z1})} * {lambda_{0}} * {lambdb_{1}} * {lambdc_{1}} + {V(p_{x1, y0, z0})} * {lambda_{1}} * {lambdb_{0}} * {lambdc_{0}} + {V(p_{x1, y0, z1})} * {lambda_{1}} * {lambdb_{0}} * {lambdc_{1}} + {V(p_{x1, y1, z0})} * {lambda_{1}} * {lambdb_{1}} * {lambdc_{0}} + {V(p_{x1, y1, z1})} * {lambda_{1}} * {lambdb_{1}} * {lambdc_{1}}$$

[object Object]

Each operator has calls. First, aclnnUpsampleTrilinear3dGetWorkspaceSize is called to obtain the workspace size required for computation and the executor that contains the operator computation process. Then, aclnnUpsampleTrilinear3d is called to perform computation.

[object Object]

• Parameters

  [object Object]

  • [object Object]Atlas inference products[object Object]

    • The data type of the input parameter self supports only FLOAT32 and FLOAT16. inf and -inf inputs are not supported.
    • The data type of the output parameter out supports only FLOAT32 and FLOAT16.

  • [object Object]Atlas training products[object Object]:

    The data types of the input parameter self and output parameter out support FLOAT32, FLOAT16, and DOUBLE.

• Returns:

  [object Object]: status code. For details, see .

  The first-phase API implements input parameter validation. The following error codes may be returned.

  [object Object]

[object Object]

• Parameters

  [object Object]

• Returns:

  [object Object]: status code. For details, see .

[object Object]

• In the input data scaling scenario, the scaling factor must be less than or equal to 50. That is:

  $$Depth of the output shape D/outputSize_D <= 50$$ $$Height of the output shape H/outputSize_H <= 50$$ $$Width of the output shape W/outputSize_W <= 50$$

• The shape constraints of self and out are as follows:

  • The value of each dimension is less than or equal to 2^20.

  • The N and C axes of out must be the same as those of self.

  • The memory usage must be less than 60 GB. The memory size can be calculated according to the following formula:

    $$N * C * (self\_D * self\_H * self\_W + out\_D * out\_H * out\_W + self\_D * self\_H * out\_W + self\_D * out\_H * out\_W) * sizeof(float) < 60 * 1024 * 1024 * 1024$$

    The values are as follows:

    • N indicates the N axis of the input and output.
    • C indicates the C axis of the input and output.

  • N * C * self_D * self_H < 2^31

  • out_W * out_H < 2^31

• The parameters self, outputSize, scalesD, scalesH, and scalesW must meet the following constraints:

  $$outputSize\_D = floor(self\_D * scalesD)$$ $$outputSize\_H = floor(self\_H * scalesH)$$ $$outputSize\_W = floor(self\_W * scalesW)$$

• Deterministic computation:

  • aclnnUpsampleTrilinear3d defaults to a deterministic implementation.

[object Object]

The following example is for reference only. For details, see .