def test_zero_pad():
np.random.seed(1)
x = np.random.randn(4, 3, 3, 2)
input_dim = x.shape[1:]
conv = Convolution(input_dim=input_dim,
pad=2,
stride=2,
num_filters=8,
filter_size=2,
seed=1)
x_pad = conv.zero_pad(x, 2)
assert (x_pad.shape == (4, 7, 7, 2))
assert (np.sum(x_pad[1, 1]) == 0)
def test_conv_step():
np.random.seed(1)
A_prev = np.random.randn(4, 4, 3)
W = np.random.randn(4, 4, 3)
b = np.random.randn(1, 1, 1)
input_dim = A_prev.shape
conv = Convolution(input_dim=input_dim,
pad=2,
stride=2,
num_filters=8,
filter_size=2,
seed=1)
Z = conv.convolve(A_prev, W, b)
assert (round(Z, 11) == -6.99908945068)
def make_cnn(input_dim, num_of_classes):
conv1 = Convolution(input_dim=input_dim,
pad=2,
stride=2,
num_filters=10,
filter_size=3,
seed=1)
relu1 = Relu()
maxpool1 = Maxpool(input_dim=conv1.output_dim, filter_size=2, stride=1)
flatten = Flatten(seed=1)
dense1 = Dense(input_dim=np.prod(maxpool1.output_dim),
output_dim=num_of_classes,
seed=1)
layers = [conv1, relu1, maxpool1, flatten, dense1]
return layers
def test_conv():
np.random.seed(1)
A_prev = np.random.randn(10, 4, 4, 3)
W = np.random.randn(2, 2, 3, 8)
b = np.random.randn(1, 1, 1, 8)
input_dim = A_prev.shape[1:]
conv = Convolution(input_dim=input_dim,
pad=2,
stride=2,
num_filters=8,
filter_size=2,
seed=1)
conv.params[0] = W
conv.params[1] = b
Z = conv.forward(A_prev)
target = np.empty(8)
target[:] = [
-0.61490741, -6.7439236, -2.55153897, 1.75698377, 3.56208902,
0.53036437, 5.18531798, 8.75898442
]
hparameters = {"pad": 2, "stride": 2}
cache_conv = (A_prev, conv.params[0], conv.params[1], hparameters)
target_cache_conv = np.empty(3)
target_cache_conv = [-0.20075807, 0.18656139, 0.41005165]
dA, grads = conv.backward(Z)
dW = grads[0]
db = grads[1]
assert (round(np.mean(Z), 13) == 0.0489952035289)
assert ((np.sum(np.around(Z[3, 2, 1], 8) != target)) == 0)
assert ((np.sum(
np.around(cache_conv[0][1][2][3], 8) != target_cache_conv)) == 0)
assert (round(np.mean(dA), 11) == 1.45243777754)
assert (round(np.mean(dW), 11) == 1.72699145831)
assert (round(np.mean(db), 11) == 7.83923256462)
def parser(self, optim_file=None):
self.modules = []
# there is no explicit input layer, the first functional layer will dirctly
# connect to the input data steam (DMA input, 16*3bits), each data is 16bits,
# thus the data width is 3
up_layer_data_shape = self.blobs.get('data').data.shape[1:]
up_layer_data_width = 1
up_layer_output_stride = 1
layer_list = list(self._layer_names)
for layer_name in layer_list:
layer_cur = self.layers[layer_list.index(layer_name)]
layer_type = layer_cur.type
if layer_type == 'Softmax' or layer_type == 'Dropout' or layer_type == 'Input':
print '{} layer will be skipped.'.format(layer_type)
continue
# get the layer information
layer_info = self.get_layer_info(layer_name)
if layer_info == None:
raise Exception(
'Layer [%s] not found, please check the model net file.' %
layer_name)
# check the layer_name,
if layer_name != layer_info.name:
raise Exception(
'Layer parse error, please check the model net file.')
if layer_type == 'Convolution' or layer_type == 'ConvolutionRistretto':
stride = 1 if len(
layer_info.convolution_param.stride
) == 0 else layer_info.convolution_param.stride[0]
pad = 0 if len(layer_info.convolution_param.pad
) == 0 else layer_info.convolution_param.pad[0]
params = [self.params[layer_name][0].data, self.params[layer_name][1].data] \
if layer_info.convolution_param.bias_term else [self.params[layer_name][0].data]
module_inst = Convolution(layer_name, up_layer_data_shape, up_layer_data_width, up_layer_output_stride, \
self.blobs[layer_info.top[0]].data.shape[1:], params, stride, pad, \
get_layer_cpf(layer_name, optim_file), get_layer_kpf(layer_name, optim_file), \
layer_info.convolution_param.group)
if layer_type == 'ConvolutionRistretto':
module_inst.set_quantization(
layer_info.quantization_param.bw_layer_in,
layer_info.quantization_param.fl_layer_in,
layer_info.quantization_param.bw_params,
layer_info.quantization_param.fl_params,
layer_info.quantization_param.bw_layer_out,
layer_info.quantization_param.fl_layer_out)
elif layer_type == 'InnerProduct' or layer_type == 'FcRistretto':
params = [self.params[layer_name][0].data, self.params[layer_name][1].data] \
if layer_info.inner_product_param.bias_term else [self.params[layer_name][0].data]
module_inst = InnerProduct(layer_name, up_layer_data_shape, up_layer_data_width, up_layer_output_stride, \
self.blobs[layer_info.top[0]].data.shape[1:], params, \
get_layer_cpf(layer_name, optim_file), get_layer_kpf(layer_name, optim_file))
if layer_type == 'FcRistretto':
module_inst.set_quantization(
layer_info.quantization_param.bw_layer_in,
layer_info.quantization_param.fl_layer_in,
layer_info.quantization_param.bw_params,
layer_info.quantization_param.fl_params,
layer_info.quantization_param.bw_layer_out,
layer_info.quantization_param.fl_layer_out)
elif layer_type == 'Pooling':
module_inst = Pooling(layer_name, up_layer_data_shape, up_layer_data_width, up_layer_output_stride, \
self.blobs[layer_info.top[0]].data.shape[1:], \
layer_info.pooling_param.pool, \
layer_info.pooling_param.kernel_size, \
layer_info.pooling_param.stride, \
layer_info.pooling_param.pad, \
get_layer_kpf(layer_name, optim_file))
module_inst.set_quantization(self.modules[-1].output_dw,
self.modules[-1].output_dq,
self.modules[-1].param_ww,
self.modules[-1].param_wq,
self.modules[-1].output_dw,
self.modules[-1].output_dq)
elif layer_type == 'BatchNorm':
params = [self.params[layer_name][0].data / self.params[layer_name][2].data, \
self.params[layer_name][1].data / self.params[layer_name][2].data]
self.modules[-1].bn = params
print 'Layer %s(%s), is aggregated to the upper layer %s.'\
%(layer_name, layer_type, self.modules[-1].layer_name)
continue
elif layer_type == 'Scale':
params = [
self.params[layer_name][0].data,
self.params[layer_name][1].data
]
self.modules[-1].bn.extend(params)
print 'Layer %s(%s), is aggregated to the upper layer %s.'\
%(layer_name, layer_type, self.modules[-1].layer_name)
continue
elif layer_type == 'ReLU':
# appregate this simple layer to the up layer
self.modules[-1].hasrelu = 1
print 'Layer %s(%s), is aggregated to the upper layer %s.'\
%(layer_name, layer_type, self.modules[-1].layer_name)
continue
else:
raise Exception('Layer type [%s] is not supported.' %
layer_type)
if module_inst.params:
module_inst.dma_delay = get_layer_dma_delay(
module_inst.layer_name, optim_file)
# add this module to the end of the list
self.modules.append(module_inst)
up_layer_data_shape = module_inst.output_shape
up_layer_data_width = module_inst.kpf
up_layer_output_stride = module_inst.get_output_stride()
if INPUT_CHANNEL_PADDING > 0:
old_shape = self.modules[0].input_shape
self.modules[0].input_shape = (old_shape[0] +
INPUT_CHANNEL_PADDING, old_shape[1],
old_shape[2])
if self.modules[0].params:
old_params_shape = self.modules[0].params[0].shape
new_params = np.zeros((old_params_shape[0], old_params_shape[1] + INPUT_CHANNEL_PADDING, \
old_params_shape[2], old_params_shape[3]))
new_params[:, 0:old_params_shape[1], :, :] = self.modules[
0].params[0]
self.modules[0].params[0] = new_params
self.modules[0].kernel_num = self.modules[0].params[0].shape[0]
self.modules[0].kernel_shape = self.modules[0].params[0].shape[
1:]
import numpy as np
np.random.seed(0)
if __name__ == '__main__':
train_data, train_labels = get_data(num_samples=50000)
test_data, test_labels = get_data(num_samples=10000, dataset="testing")
train_data = train_data / 255
test_data = test_data / 255
print("Train data shape: {}, {}".format(train_data.shape, train_labels.shape))
print("Test data shape: {}, {}".format(test_data.shape, test_labels.shape))
model = Model(
Convolution(filters=5, padding='same'),
Elu(),
Pooling(mode='max', kernel_shape=(2, 2), stride=2),
Flatten(),
FullyConnected(units=10),
Softmax(),
name='cnn5'
)
model.set_loss(CategoricalCrossEntropy)
model.train(train_data, train_labels.T, epochs=2) # set load_and_continue to True if you want to start from already trained weights
# model.load_weights() # uncomment if loading previously trained weights and comment above line to skip training and only load trained weights.
print('Testing accuracy = {}'.format(model.evaluate(test_data, test_labels)))