ND Convolution Backprogation

Für meine Ausbildung versuche ich, eine N-dimensionale Faltungsschicht in einem Faltungsnetzwerk zu implementieren.

Ich möchte eine Backpropagation-Funktion implementieren. Ich bin mir jedoch nicht sicher, wie ich dies am effizientesten tun kann.

Zur Zeit benutze ich signal.fftconvolve:

Falten Sie im Vorwärtsschritt den Filter und den Kernel vorwärts über alle Filter.
Falten Sie im Backpropagation-Schritt die Ableitungen (in allen Dimensionen mit der FlipAllAxes-Funktion umgekehrt) mit dem Array ( https://jefkine.com/general/2016/09/05/backpropagation-in-convolutional-neural-networks/ ) alle Filter und summiere sie. Die Ausgabe, die ich nehme, ist die Summe jedes Bildes, das mit jeder Ableitung für jeden Filter gefaltet wird.

Ich bin besonders verwirrt darüber, wie man die Derivate faltet . Die Verwendung der folgenden Klasse zur Rückausbreitung führt zu einer Explosion der Größe der Gewichte.

Was ist der richtige Weg, um die Faltung der Ableitung mit dem Ausgang und den Filtern zu programmieren?

BEARBEITEN:

Laut diesem Artikel ( Fast Training of Convolutional Networks durch FFTs ), der genau das tun möchte, was ich tun möchte:

Die Ableitungen für die vorherige Schicht ergeben sich aus der Faltung der Ableitungen der aktuellen Schicht mit den Gewichten:

dL / dy_f = dL / dx * w_f ^ T.
Die Ableitung für die Gewichte ist die stückweise Summe der Faltung der Ableitungen mit der ursprünglichen Eingabe:

dL / dy = dL / dx * x

Ich habe dies nach bestem Wissen und Gewissen umgesetzt. Dies scheint jedoch nicht das beabsichtigte Ergebnis zu liefern, da das Netzwerk, das ich mit dieser Ebene geschrieben habe, während des Trainings wilde Schwankungen aufweist.

    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
quelle

ND Convolution Backprogation

Antworten: