abstract_conv.py 文件源码

def conv(self, img, kern, mode="valid", dilation=1):
        """
        Basic slow Python 2D or 3D convolution for DebugMode
        """

        if not imported_scipy_signal:
            raise NotImplementedError(
                "AbstractConv perform requires the python package"
                " for scipy.signal to be installed.")
        if not (mode in ('valid', 'full')):
            raise ValueError(
                'invalid mode {}, which must be either '
                '"valid" or "full"'.format(mode))
        if isinstance(dilation, integer_types):
            dilation = (dilation,) * self.convdim
        if len(dilation) != self.convdim:
            raise ValueError(
                'invalid dilation {}, expected {} values'.format(dilation,
                                                                 self.convdim))

        out_shape = get_conv_output_shape(img.shape, kern.shape,
                                          mode, [1] * self.convdim, dilation)

        out = numpy.zeros(out_shape, dtype=img.dtype)
        dil_kern_shp = kern.shape[:-self.convdim] + tuple(
            (kern.shape[-self.convdim + i] - 1) * dilation[i] + 1
            for i in range(self.convdim))
        dilated_kern = numpy.zeros(dil_kern_shp, dtype=kern.dtype)
        dilated_kern[(slice(None), slice(None)) +
                     tuple(slice(None, None, dilation[i]) for i in range(self.convdim))
                     ] = kern

        if self.convdim == 2:
            val = _valfrommode(mode)
            bval = _bvalfromboundary('fill')

            with warnings.catch_warnings():
                warnings.simplefilter('ignore', numpy.ComplexWarning)
                for b in xrange(img.shape[0]):
                    for n in xrange(kern.shape[0]):
                        for im0 in xrange(img.shape[1]):
                            # some cast generates a warning here
                            out[b, n, ...] += _convolve2d(img[b, im0, ...],
                                                          dilated_kern[n, im0, ...],
                                                          1, val, bval, 0)
        elif self.convdim == 3:
            for b in xrange(img.shape[0]):
                for n in xrange(kern.shape[0]):
                    for im0 in xrange(img.shape[1]):
                        out[b, n, ...] += convolve(img[b, im0, ...],
                                                   dilated_kern[n, im0, ...],
                                                   mode)
        else:
            raise NotImplementedError('only 2D and 3D convolution are implemented')
        return out