a 8Sic6@srdZddlZddlmZmZmZddlZdddZdddZdd d Z dd d Z dd dZ dddZ dddZ dS)zGradient interfaceN)_single_pair_triplec sdur tddgttd}t|dkrR| dt|krvtd|dtfddfddt|Dfd dt|D}t|D]:\}} } || ks|| krtd | ddqt fd d t|DS) NzK_grad_input_padding 'dilation' argument not provided. Default of 1 is used.rz)input_size must have {} elements (got {})cs>|dd|d|d||dS)Nrr)size)d)dilation grad_output kernel_sizepaddingstrideI/var/www/html/django/DPS/env/lib/python3.9/site-packages/torch/nn/grad.pydim_sizes(z%_grad_input_padding..dim_sizecsg|] }|qSrr.0r)rrr z'_grad_input_padding..cs g|]}||dqS)rrr) min_sizesr rrrrzarequested an input grad size of {}, but valid sizes range from {} to {} (for a grad_output of {})c3s|]}||VqdS)Nrr) input_sizerrr %rz&_grad_input_padding..) warningswarnlenlistdim ValueErrorformatrangeziprtuple) r rr r r r kZ max_sizesrmin_sizemax_sizer)r rr rr rr r r_grad_input_paddings.    r%c Cs^t|}t|}t|}|jdg}|dur4tdt||||||}t||d|||||S)a Computes the gradient of conv1d with respect to the input of the convolution. This is same as the 1D transposed convolution operator under the hood but requires the shape of the gradient w.r.t. input to be specified explicitly. Args: input_size : Shape of the input gradient tensor weight: weight tensor (out_channels x in_channels/groups x kW) grad_output : output gradient tensor (minibatch x out_channels x oW) stride (int or tuple, optional): Stride of the convolution. Default: 1 padding (int or tuple, optional): Zero-padding added to both sides of the input. Default: 0 dilation (int or tuple, optional): Spacing between kernel elements. Default: 1 groups (int, optional): Number of blocked connections from input channels to output channels. Default: 1 Examples:: >>> input = torch.randn(1,1,3, requires_grad=True) >>> weight = torch.randn(1,1,1, requires_grad=True) >>> output = F.conv1d(input, weight) >>> grad_output = torch.randn(output.shape) >>> grad_input = torch.autograd.grad(output, input, grad_output) >>> F.grad.conv1d_input(input.shape, weight, grad_output) rNz3grad.conv1d_input requires specifying an input_size)rshaperr%torchconv_transpose1d rweightr r r r groupsr Zgrad_input_paddingrrr conv1d_input(s r,c Cst|}t|}t|}|jd}|jd}|jd} |d||d}||jd|jdd|jd}|d|jd|jd|jd}t||d||||| } | | | jd| | jd} | jdd|||| jddd dd|dS)a! Computes the gradient of conv1d with respect to the weight of the convolution. Args: input: input tensor of shape (minibatch x in_channels x iW) weight_size : Shape of the weight gradient tensor grad_output : output gradient tensor (minibatch x out_channels x oW) stride (int or tuple, optional): Stride of the convolution. Default: 1 padding (int or tuple, optional): Zero-padding added to both sides of the input. Default: 0 dilation (int or tuple, optional): Spacing between kernel elements. Default: 1 groups (int, optional): Number of blocked connections from input channels to output channels. Default: 1 Examples:: >>> input = torch.randn(1,1,3, requires_grad=True) >>> weight = torch.randn(1,1,1, requires_grad=True) >>> output = F.conv1d(input, weight) >>> grad_output = torch.randn(output.shape) >>> grad_weight = torch.autograd.grad(output, filter, grad_output) >>> F.grad.conv1d_weight(input, weight.shape, grad_output) rrrNr) rr& contiguousrepeatviewr'conv1dsum transposenarrow inputZ weight_sizer r r r r+Z in_channelsZ out_channelsZ min_batchZ grad_weightrrr conv1d_weightQs4     r7c Csft|}t|}t|}|jd|jdf}|dur>> input = torch.randn(1,1,3,3, requires_grad=True) >>> weight = torch.randn(1,1,1,2, requires_grad=True) >>> output = F.conv2d(input, weight) >>> grad_output = torch.randn(output.shape) >>> grad_input = torch.autograd.grad(output, input, grad_output) >>> F.grad.conv2d_input(input.shape, weight, grad_output) rNz3grad.conv2d_input requires specifying an input_size)rr&rr%r'conv_transpose2dr)rrr conv2d_inputsr:c Cs>t|}t|}t|}|jd}|jd}|jd} |d||dd}||jd|jdd|jd|jd}|d|jd|jd|jd|jd}t||d||||| } | | | jd| | jd| jd} | jdd|||| jd| jddd dd|d dd|dS)a/ Computes the gradient of conv2d with respect to the weight of the convolution. Args: input: input tensor of shape (minibatch x in_channels x iH x iW) weight_size : Shape of the weight gradient tensor grad_output : output gradient tensor (minibatch x out_channels x oH x oW) stride (int or tuple, optional): Stride of the convolution. Default: 1 padding (int or tuple, optional): Zero-padding added to both sides of the input. Default: 0 dilation (int or tuple, optional): Spacing between kernel elements. Default: 1 groups (int, optional): Number of blocked connections from input channels to output channels. Default: 1 Examples:: >>> input = torch.randn(1,1,3,3, requires_grad=True) >>> weight = torch.randn(1,1,1,2, requires_grad=True) >>> output = F.conv2d(input, weight) >>> grad_output = torch.randn(output.shape) >>> grad_weight = torch.autograd.grad(output, filter, grad_output) >>> F.grad.conv2d_weight(input, weight.shape, grad_output) rrrr8Nr-) rr&r.r/r0r'conv2dr2r3r4r5rrr conv2d_weightsB      r<c Csnt|}t|}t|}|jd|jd|jdf}|durDtdt||||||}t||d|||||S)a Computes the gradient of conv3d with respect to the input of the convolution. This is same as the 3D transposed convolution operator under the hood but requires the shape of the gradient w.r.t. input to be specified explicitly. Args: input_size : Shape of the input gradient tensor weight: weights tensor (out_channels x in_channels/groups x kT x kH x kW) grad_output : output gradient tensor (minibatch x out_channels x oT x oH x oW) stride (int or tuple, optional): Stride of the convolution. Default: 1 padding (int or tuple, optional): Zero-padding added to both sides of the input. Default: 0 dilation (int or tuple, optional): Spacing between kernel elements. Default: 1 groups (int, optional): Number of blocked connections from input channels to output channels. Default: 1 Examples:: >>> input = torch.randn(2, 8, 10, 10, 20, requires_grad=True) >>> weight = torch.randn(4, 8, 2, 3, 3, requires_grad=True) >>> output = F.conv3d(input, weight) >>> grad_output = torch.randn(output.shape) >>> grad_input = torch.autograd.grad(output, input, grad_output) >>> F.grad.conv3d_input(input.shape, weight, grad_output) rr8Nz3grad.conv3d_input requires specifying an input_size)rr&rr%r'conv_transpose3dr)rrr conv3d_inputsr?c Csjt|}t|}t|}|jd}|jd}|jd} |d||ddd}||jd|jdd|jd|jd|jd}|d|jd|jd|jd|jd|jd}t||d||||| } | | | jd| | jd| jd| jd} | jdd|||| jd| jd| jddd dd|d dd|d dd|dS)aH Computes the gradient of conv3d with respect to the weight of the convolution. Args: input: input tensor of shape (minibatch x in_channels x iT x iH x iW) weight_size : Shape of the weight gradient tensor grad_output : output gradient tensor (minibatch x out_channels x oT x oH x oW) stride (int or tuple, optional): Stride of the convolution. Default: 1 padding (int or tuple, optional): Zero-padding added to both sides of the input. Default: 0 dilation (int or tuple, optional): Spacing between kernel elements. Default: 1 groups (int, optional): Number of blocked connections from input channels to output channels. Default: 1 Examples:: >>> input = torch.randn(2, 8, 10, 10, 20, requires_grad=True) >>> weight = torch.randn(4, 8, 2, 3, 3, requires_grad=True) >>> output = F.conv3d(input, weight) >>> grad_output = torch.randn(output.shape) >>> grad_weight = torch.autograd.grad(output, weight, grad_output) >>> F.grad.conv3d_weight(input, weight.shape, grad_output) rrrr8r=Nr-) rr&r/r.r0r'conv3dr2r3r4r5rrr conv3d_weightsD       rA)N)rrrr)rrrr)rrrr)rrrr)rrrr)rrrr)__doc__r' modules.utilsrrrrr%r,r7r:r<r?rArrrrs ) 0 ) 4 )