MaxPool3d#

classtorch.nn.modules.pooling.MaxPool3d(kernel_size,stride=None,padding=0,dilation=1,return_indices=False,ceil_mode=False)[source]#

Applies a 3D max pooling over an input signal composed of several input planes.

In the simplest case, the output value of the layer with input size$(N,C,D,H,W)$(N,C,D,H,W),output$(N,C,D_{out},H_{out},W_{out})$(N,C,Dout​,Hout​,Wout​) andkernel_size$(kD,kH,kW)$(kD,kH,kW)can be precisely described as:

out(Ni​,Cj​,d,h,w)=​k=0,…,kD−1max​m=0,…,kH−1max​n=0,…,kW−1max​input(Ni​,Cj​,stride[0]×d+k,stride[1]×h+m,stride[2]×w+n)​

Ifpadding is non-zero, then the input is implicitly padded with negative infinity on both sidesforpadding number of points.dilation controls the spacing between the kernel points.It is harder to describe, but thislink has a nice visualization of whatdilation does.

Note

When ceil_mode=True, sliding windows are allowed to go off-bounds if they start within the left paddingor the input. Sliding windows that would start in the right padded region are ignored.

The parameterskernel_size,stride,padding,dilation can either be:

• a singleint – in which case the same value is used for the depth, height and width dimension

• atuple of three ints – in which case, the firstint is used for the depth dimension,the secondint for the height dimension and the thirdint for the width dimension

Parameters

• kernel_size (Union[int,tuple[int,int,int]]) – the size of the window to take a max over

• stride (Union[int,tuple[int,int,int]]) – the stride of the window. Default value iskernel_size

• padding (Union[int,tuple[int,int,int]]) – Implicit negative infinity padding to be added on all three sides

• dilation (Union[int,tuple[int,int,int]]) – a parameter that controls the stride of elements in the window

• return_indices (bool) – ifTrue, will return the max indices along with the outputs.Useful fortorch.nn.MaxUnpool3d later

• ceil_mode (bool) – when True, will useceil instead offloor to compute the output shape

Shape:

• Input:$(N,C,D_{in},H_{in},W_{in})$(N,C,Din​,Hin​,Win​) or$(C,D_{in},H_{in},W_{in})$(C,Din​,Hin​,Win​).

• Output:$(N,C,D_{out},H_{out},W_{out})$(N,C,Dout​,Hout​,Wout​) or$(C,D_{out},H_{out},W_{out})$(C,Dout​,Hout​,Wout​), where

  $$D_{out}=\lfloor \frac{D_{in}+2\times \text{padding}[0]-\text{dilation}[0]\times (\text{kernel\_size}[0]-1)-1}{\text{stride}[0]}+1\rfloor$$Dout​=⌊stride[0]Din​+2×padding[0]−dilation[0]×(kernel_size[0]−1)−1​+1⌋
  $$H_{out}=\lfloor \frac{H_{in}+2\times \text{padding}[1]-\text{dilation}[1]\times (\text{kernel\_size}[1]-1)-1}{\text{stride}[1]}+1\rfloor$$Hout​=⌊stride[1]Hin​+2×padding[1]−dilation[1]×(kernel_size[1]−1)−1​+1⌋
  $$W_{out}=\lfloor \frac{W_{in}+2\times \text{padding}[2]-\text{dilation}[2]\times (\text{kernel\_size}[2]-1)-1}{\text{stride}[2]}+1\rfloor$$Wout​=⌊stride[2]Win​+2×padding[2]−dilation[2]×(kernel_size[2]−1)−1​+1⌋

Examples:

>>># pool of square window of size=3, stride=2>>>m=nn.MaxPool3d(3,stride=2)>>># pool of non-square window>>>m=nn.MaxPool3d((3,2,2),stride=(2,1,2))>>>input=torch.randn(20,16,50,44,31)>>>output=m(input)

forward(input)[source]#

Runs the forward pass.