예제 #1
0
 def load_weights(self, dump_path):
     if self.name is None:
         self.name = '{}_{}'.format(self.type, get_layer_num(self.type))
         inc_layer_num(self.type)
     read_path = path.join(dump_path, self.name + '.pickle')
     with open(read_path, 'rb') as r:
         dump_cache = pickle.load(r)
     self.cache = dump_cache['cache']
     self.grads = dump_cache['grads']
     self.momentum_cache = dump_cache['momentum']
     self.rmsprop_cache = dump_cache['rmsprop']
예제 #2
0
    def forward_propagate(self, X, save_cache=False):
        if self.name is None:
            self.name = '{}_{}'.format(self.type, get_layer_num(self.type))
            inc_layer_num(self.type)

        if 'W' not in self.params:
            self.params['W'], self.params['b'] = he_normal((X.shape[0], self.units))
        Z = np.dot(self.params['W'], X) + self.params['b']
        if save_cache:
            self.cache['A'] = X
        return Z
예제 #3
0
    def forward_propagate(self, X, save_cache=False):
        '''

        :param X:
        :param save_cache:
        :return:
        '''
        if self.name is None:
            self.name = '{}_{}'.format(self.type, get_layer_num(self.type))
            inc_layer_num(self.type)

        (num_data_points, prev_height, prev_width, prev_channels) = X.shape
        filter_shape_h, filter_shape_w = self.params['kernel_shape']

        if 'W' not in self.params:
            shape = (filter_shape_h, filter_shape_w, prev_channels,
                     self.params['filters'])
            self.params['W'], self.params['b'] = glorot_uniform(shape=shape)

        if self.params['padding'] == 'same':
            pad_h = int(((prev_height - 1) * self.params['stride'] +
                         filter_shape_h - prev_height) / 2)
            pad_w = int(((prev_width - 1) * self.params['stride'] +
                         filter_shape_w - prev_width) / 2)
            n_H = prev_height
            n_W = prev_width
        else:
            pad_h = 0
            pad_w = 0
            n_H = int(
                (prev_height - filter_shape_h) / self.params['stride']) + 1
            n_W = int(
                (prev_width - filter_shape_w) / self.params['stride']) + 1

        self.params['pad_h'], self.params['pad_w'] = pad_h, pad_w

        Z = np.zeros(shape=(num_data_points, n_H, n_W, self.params['filters']))

        X_pad = pad_inputs(X, (pad_h, pad_w))

        for i in range(num_data_points):
            x = X_pad[i]
            for h in range(n_H):
                for w in range(n_W):
                    vert_start = self.params['stride'] * h
                    vert_end = vert_start + filter_shape_h
                    horiz_start = self.params['stride'] * w
                    horiz_end = horiz_start + filter_shape_w

                    for c in range(self.params['filters']):

                        x_slice = x[vert_start:vert_end,
                                    horiz_start:horiz_end, :]

                        Z[i, h, w, c] = self.conv_single_step(
                            x_slice, self.params['W'][:, :, :, c],
                            self.params['b'][:, :, :, c])

        if save_cache:
            self.cache['A'] = X

        return Z