Exemple #1
0
    def _grads(self, delta, delta_space, X):
        grad_W = conv.fftconv1d(np.fliplr(delta), X, n_threads=self.n_threads, mode='valid')
        grad_W_space = delta_space.with_extents(w=grad_W.shape[1])

        grad_W, grad_W_space = grad_W_space.transform(grad_W, grad_W_space.folded_axes)

        grad_W = grad_W.sum(axis=grad_W_space.axes.index('b'))
        grad_W_space = grad_W_space.without_axes('b')
        grad_W, grad_W_space = grad_W_space.transform(grad_W, [('b', 'd', 'f', 'c'), 'w'])

        return [grad_W]
Exemple #2
0
    def _fprop(self, X, X_space):
        K, _ = self._kernel_space.broadcast(np.fliplr(self.W), b=X_space.get_extent('b'))
        X = conv.fftconv1d(X, K, n_threads=self.n_threads)

        X_space = X_space.with_extents(w=X.shape[1])

        X, X_space = X_space.transform(X, (('b', 'd', 'f'), 'c', 'w'))
        X = X.sum(axis=X_space.axes.index('c'))
        X_space = X_space.without_axes('c')

        return X, X_space
Exemple #3
0
    def _bprop(self, delta, delta_space):
        K, _ = self._kernel_space.broadcast(self.W, b=delta_space.get_extent('b'))

        delta = conv.fftconv1d(delta, K, n_threads=self.n_threads, mode='valid')
        delta_space = delta_space.with_extents(w=delta.shape[1])

        delta, delta_space = delta_space.transform(delta, delta_space.folded_axes)
        delta = delta.sum(axis=delta_space.axes.index('f'))
        delta_space = delta_space.without_axes('f')
        delta_space = delta_space.rename_axes(c='f')

        return delta, delta_space
Exemple #4
0
    def _fprop(self, X, X_space):
        K, _ = self._kernel_space.broadcast(np.fliplr(self.W),
                                            b=X_space.get_extent('b'))
        X = conv.fftconv1d(X, K, n_threads=self.n_threads)

        X_space = X_space.with_extents(w=X.shape[1])

        X, X_space = X_space.transform(X, (('b', 'd', 'f'), 'c', 'w'))
        X = X.sum(axis=X_space.axes.index('c'))
        X_space = X_space.without_axes('c')

        return X, X_space
Exemple #5
0
    def _run_fftconv1d(self, n_x, n_k, mode):
        n_rows = 2

        X = np.random.standard_normal(size=(n_rows, n_x))
        K = np.random.uniform(size=(n_rows, n_k))

        actual = conv.fftconv1d(X, K, mode=mode)
        expected = self.reference_convolve(X, K, mode=mode)

        print "X:", X.shape, "K:", K.shape, "A:", actual.shape, "E:", expected.shape
        print actual
        print
        print expected

        assert np.allclose(actual, expected)
Exemple #6
0
    def _run_fftconv1d(self, n_x, n_k, mode):
        n_rows = 2

        X = np.random.standard_normal(size=(n_rows, n_x))
        K = np.random.uniform(size=(n_rows, n_k))

        actual = conv.fftconv1d(X, K, mode=mode)
        expected = self.reference_convolve(X, K, mode=mode)

        print "X:", X.shape, "K:", K.shape, "A:", actual.shape, "E:", expected.shape
        print actual
        print
        print expected

        assert np.allclose(actual, expected)
Exemple #7
0
    def _grads(self, delta, delta_space, X):
        grad_W = conv.fftconv1d(np.fliplr(delta),
                                X,
                                n_threads=self.n_threads,
                                mode='valid')
        grad_W_space = delta_space.with_extents(w=grad_W.shape[1])

        grad_W, grad_W_space = grad_W_space.transform(grad_W,
                                                      grad_W_space.folded_axes)

        grad_W = grad_W.sum(axis=grad_W_space.axes.index('b'))
        grad_W_space = grad_W_space.without_axes('b')
        grad_W, grad_W_space = grad_W_space.transform(
            grad_W, [('b', 'd', 'f', 'c'), 'w'])

        return [grad_W]
Exemple #8
0
    def _bprop(self, delta, delta_space):
        K, _ = self._kernel_space.broadcast(self.W,
                                            b=delta_space.get_extent('b'))

        delta = conv.fftconv1d(delta,
                               K,
                               n_threads=self.n_threads,
                               mode='valid')
        delta_space = delta_space.with_extents(w=delta.shape[1])

        delta, delta_space = delta_space.transform(delta,
                                                   delta_space.folded_axes)
        delta = delta.sum(axis=delta_space.axes.index('f'))
        delta_space = delta_space.without_axes('f')
        delta_space = delta_space.rename_axes(c='f')

        return delta, delta_space