function conv2DBackpropInput_(xShape, dy, filter, strides, pad, dataFormat = "NHWC", dimRoundingMode) {
    _util.assert(xShape.length === dy.rank, ()=>`Length of inShape ` + `(${xShape.length}) and rank of dy (${dy.rank}) must match`);
    let xShape4D = xShape;
    let dy4D = dy;
    let reshapedTo4D = false;
    if (dy.rank === 3) {
        reshapedTo4D = true;
        dy4D = (0, _reshape.reshape)(dy, [
            1,
            dy.shape[0],
            dy.shape[1],
            dy.shape[2]
        ]);
        xShape4D = [
            1,
            xShape[0],
            xShape[1],
            xShape[2]
        ];
    }
    _util.assert(xShape4D.length === 4, ()=>`Error in conv2dDerInput: inShape must be length 4, but got length ` + `${xShape4D.length}.`);
    _util.assert(dy4D.rank === 4, ()=>`Error in conv2dDerInput: dy must be rank 4, but got ` + `rank ${dy4D.rank}`);
    _util.assert(filter.rank === 4, ()=>`Error in conv2dDerInput: filter must be rank 4, but got ` + `rank ${filter.rank}`);
    const inDepth = dataFormat === "NHWC" ? xShape4D[3] : xShape4D[1];
    const outDepth = dataFormat === "NHWC" ? dy4D.shape[3] : dy4D.shape[1];
    _util.assert(inDepth === filter.shape[2], ()=>`Error in conv2dDerInput: depth of input (${inDepth}) must ` + `match input depth for filter ${filter.shape[2]}.`);
    _util.assert(outDepth === filter.shape[3], ()=>`Error in conv2dDerInput: depth of output (${outDepth}) must ` + `match output depth for filter ${filter.shape[3]}.`);
    _convUtil.checkPadOnDimRoundingMode("conv2dDerInput", pad, dimRoundingMode);
    const inputs = {
        dy: dy4D,
        filter
    };
    const attrs = {
        strides,
        pad,
        dataFormat,
        dimRoundingMode,
        inputShape: xShape4D
    };
    // tslint:disable-next-line: no-unnecessary-type-assertion
    const res = (0, _engine.ENGINE).runKernel((0, _kernelNames.Conv2DBackpropInput), inputs, attrs);
    if (reshapedTo4D) return (0, _reshape.reshape)(res, [
        res.shape[1],
        res.shape[2],
        res.shape[3]
    ]);
    return res;
}
Computes the derivative of the input of a 2D convolution.

@param xShape The shape of the input: [batch, height, width, inDepth].
If length of 3, batch of 1 is assumed.
@param dy The derivative of the output, of rank 4 or rank 3 of shape
  `[batch, outHeight, outWidth, outDepth]`. If rank 3, batch of 1 is
assumed.
@param filter The filter, rank 4, of shape
    `[filterHeight, filterWidth, inDepth, outDepth]`.
@param strides The strides of the convolution: `[strideHeight,
strideWidth]`.
@param pad The type of padding algorithm used:
   - `same` and stride 1: output will be of same size as input,
      regardless of filter size.
   - `valid`: output will be smaller than input if filter is larger
      than 1x1.
@param dataFormat: An optional string from: "NHWC", "NCHW". Defaults to
    "NHWC". Specify the data format of the input and output data. With the
    default format "NHWC", the data is stored in the order of: [batch,
    height, width, channels].
@param dimRoundingMode A string from: 'ceil', 'round', 'floor'. If none is
    provided, it will default to truncate.