ND Convolución Backprogation

Para mi educación, estoy tratando de implementar una capa convolucional N-dimensional en una red neuronal convolucional.

Me gustaría implementar una función de retropropagación. Sin embargo, no estoy seguro de la forma más eficiente de hacerlo.

Actualmente, estoy usando signal.fftconvolvepara:

En el paso hacia adelante, convolucione el filtro y el kernel hacia adelante sobre todos los filtros;
En el paso Backpropagation, convolucione los derivados (invertidos en todas las dimensiones con la función FlipAllAxes) con la matriz ( https://jefkine.com/general/2016/09/05/backpropagation-in-convolutional-neural-networks/ ) sobre todos los filtros y sumarlos. La salida que considero es la suma de cada imagen convolucionada con cada derivada para cada filtro.

Estoy particularmente confundido acerca de cómo convolucionar los derivados . El uso de la clase a continuación para propagar hacia atrás da como resultado una explosión en el tamaño de los pesos.

¿Cuál es la forma correcta de programar la convolución de la derivada con la salida y los filtros?

EDITAR:

De acuerdo con este documento ( Capacitación rápida de redes convolucionales a través de FFT ), que busca hacer exactamente lo que deseo hacer:

Las derivadas para la capa anterior están dadas por la convolución de las derivadas de la capa actual con los pesos:

dL / dy_f = dL / dx * w_f ^ T
La derivada para los pesos es la suma por partes de la convolución de las derivadas con la entrada original:

dL / dy = dL / dx * x

He implementado, lo mejor que sé cómo, esto a continuación. Sin embargo, esto no parece dar el resultado deseado, ya que la red que he escrito usando esta capa exhibe fluctuaciones salvajes durante el entrenamiento.

    import numpy as np
    from scipy import signal

    class ConvNDLayer:
        def __init__(self,channels, kernel_size, dim):

            self.channels = channels
            self.kernel_size = kernel_size;
            self.dim = dim

            self.last_input = None

            self.filt_dims = np.ones(dim+1).astype(int)
            self.filt_dims[1:] =  self.filt_dims[1:]*kernel_size
            self.filt_dims[0]= self.filt_dims[0]*channels 
            self.filters = np.random.randn(*self.filt_dims)/(kernel_size)**dim


        def FlipAllAxes(self, array):

            sl = slice(None,None,-1)
            return array[tuple([sl]*array.ndim)] 

        def ViewAsWindows(self, array, window_shape, step=1):
             # -- basic checks on arguments
             if not isinstance(array, cp.ndarray):
                 raise TypeError("`array` must be a Cupy ndarray")
             ndim = array.ndim
             if isinstance(window_shape, numbers.Number):
                  window_shape = (window_shape,) * ndim
             if not (len(window_shape) == ndim):
                   raise ValueError("`window_shape` is incompatible with `arr_in.shape`")

             if isinstance(step, numbers.Number):
                  if step < 1:
                  raise ValueError("`step` must be >= 1")
                  step = (step,) * ndim
             if len(step) != ndim:
                   raise ValueError("`step` is incompatible with `arr_in.shape`")

              arr_shape = array.shape
              window_shape = np.asarray(window_shape, dtype=arr_shape.dtype))

              if ((arr_shape - window_shape) < 0).any():
                   raise ValueError("`window_shape` is too large")

              if ((window_shape - 1) < 0).any():
                    raise ValueError("`window_shape` is too small")

               # -- build rolling window view
                    slices = tuple(slice(None, None, st) for st in step)
                    window_strides = array.strides
                    indexing_strides = array[slices].strides
                    win_indices_shape = (((array.shape -window_shape)
                    // step) + 1)

                 new_shape = tuple(list(win_indices_shape) + list(window_shape))
                 strides = tuple(list(indexing_strides) + list(window_strides))

                  arr_out = as_strided(array, shape=new_shape, strides=strides)

                  return arr_out

        def UnrollAxis(self, array, axis):
             # This so it works with a single dimension or a sequence of them
             axis = cp.asnumpy(cp.atleast_1d(axis))
             axis2 = cp.asnumpy(range(len(axis)))

             # Put unrolled axes at the beginning
             array = cp.moveaxis(array, axis,axis2)
             # Unroll
             return array.reshape((-1,) + array.shape[len(axis):])

        def Forward(self, array):

             output_shape =cp.zeros(array.ndim + 1)    
             output_shape[1:] =  cp.asarray(array.shape)
             output_shape[0]= self.channels 
             output_shape = output_shape.astype(int)
             output = cp.zeros(cp.asnumpy(output_shape))

             self.last_input = array

             for i, kernel in enumerate(self.filters):
                    conv = self.Convolve(array, kernel)
                    output[i] = conv

             return output


        def Backprop(self, d_L_d_out, learn_rate):

            d_A= cp.zeros_like(self.last_input)
            d_W = cp.zeros_like(self.filters)


           for i, (kernel, d_L_d_out_f) in enumerate(zip(self.filters, d_L_d_out)):

                d_A += signal.fftconvolve(d_L_d_out_f, kernel.T, "same")
                conv = signal.fftconvolve(d_L_d_out_f, self.last_input, "same")
                conv = self.ViewAsWindows(conv, kernel.shape)
                axes = np.arange(kernel.ndim)
                conv = self.UnrollAxis(conv, axes)  
                d_W[i] = np.sum(conv, axis=0)


           output = d_A*learn_rate
           self.filters =  self.filters - d_W*learn_rate
           return output

python conv-neural-network convolution backpropagation Jack Rolph
fuente

ND Convolución Backprogation

Respuestas: