function conv3DBackpropFilter_(x, dy, filterShape, strides, pad) {
	  var x5D = x;

	  if (x.rank === 4) {
	    x5D = reshape(x, [1, x.shape[0], x.shape[1], x.shape[2], x.shape[3]]);
	  }

	  var dy5D = dy;

	  if (dy5D.rank === 4) {
	    dy5D = reshape(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2], dy.shape[3]]);
	  }

	  assert(x5D.rank === 5, function () {
	    return "Error in conv3dDerFilter: input must be rank 5, but got shape " + (x5D.shape + ".");
	  });
	  assert(dy5D.rank === 5, function () {
	    return "Error in conv3dDerFilter: dy must be rank 5, but got shape " + (dy5D.shape + ".");
	  });
	  assert(filterShape.length === 5, function () {
	    return "Error in conv3dDerFilter: filterShape must be length 5, but got " + (filterShape + ".");
	  });
	  assert(x5D.shape[4] === filterShape[3], function () {
	    return "Error in conv3dDerFilter: depth of input " + x5D.shape[4] + ") must " + ("match input depth in filter (" + filterShape[3] + ".");
	  });
	  assert(dy5D.shape[4] === filterShape[4], function () {
	    return "Error in conv3dDerFilter: depth of dy (" + dy5D.shape[4] + ") must " + ("match output depth for filter (" + filterShape[4] + ").");
	  });
	  var inputs = {
	    x: x5D,
	    dy: dy5D
	  };
	  var attrs = {
	    strides: strides,
	    pad: pad,
	    filterShape: filterShape
	  }; // tslint:disable-next-line: no-unnecessary-type-assertion

	  return ENGINE.runKernel(Conv3DBackpropFilterV2, inputs, attrs);
	}
Computes the derivative of the filter of a 3D convolution.

@param x The input tensor, of rank 5 or rank 4 of shape
    [batch, depth, height, width, inChannels]. If rank 4, batch of 1 is
    assumed.
@param dy The dy image, of rank 5 or rank 4, of shape
    [batch, depth, height, width, outDepth]. If rank 4, batch of 1 is
    assumed.
@param filterShape The shape of the filter, length 5,
    [filterDepth, filterHeight, filterWidth, inDepth, outDepth].
@param strides The strides of the convolution: [strideDepth, strideHeight,
strideWidth].
@param pad A string from: 'same', 'valid'. The type of padding algorithm
    used in the forward prop of the op.