def test_hdf5_layer(tmpdir): td = tmpdir.mkdir('test_hdf5_layer') path_h5 = td.join('h5layer.in.h5').ensure().strpath n_sample = 5 names = ['data%02d' % i for i in xrange(n_sample)] blob_name = 'blob1' batch_size = 2 blob_shape = (1, 2, 3) data = np.random.rand(*((n_sample, ) + blob_shape)) import h5py with h5py.File(path_h5, 'w') as hd: for i, name in enumerate(names): hd.create_group(name) hd[name][blob_name] = data[i] import csv lpath_source = td.join('source.txt').ensure() csv.writer(lpath_source.open('w')).writerows(map(lambda x: [x], names)) t = caffe.Blob([]) bottom = [] top = [t] # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.data_layers" lp.python_param.layer = "HDF5Layer" lp.python_param.param_str = str( dict(batch_size=batch_size, source=lpath_source.strpath, path_h5=path_h5, column_id=0, blob_name='blob1')) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) j = 0 for i in xrange(3): layer.Reshape(bottom, top) layer.Forward(bottom, top) assert top[0].shape == (batch_size, ) + blob_shape for blob in top[0].data: j %= n_sample assert np.all(blob == data[j].astype(np.float32)) j += 1 # Shuffle: Values are not checked here so far. lp.python_param.param_str = str( dict(batch_size=batch_size, source=lpath_source.strpath, path_h5=path_h5, column_id=0, blob_name='blob1', shuffle=True, random_seed=313)) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) for i in xrange(3): layer.Reshape(bottom, top) layer.Forward(bottom, top) assert top[0].shape == (batch_size, ) + blob_shape
def test_hdf5_layer(tmpdir): td = tmpdir.mkdir('test_hdf5_layer') path_h5 = td.join('h5layer.in.h5').ensure().strpath n_sample = 5 names = ['data%02d' % i for i in xrange(n_sample)] blob_name = 'blob1' batch_size = 2 blob_shape = (1, 2, 3) data = np.random.rand(*((n_sample,) + blob_shape)) import h5py with h5py.File(path_h5, 'w') as hd: for i, name in enumerate(names): hd.create_group(name) hd[name][blob_name] = data[i] import csv lpath_source = td.join('source.txt').ensure() csv.writer(lpath_source.open('w')).writerows(map(lambda x: [x], names)) t = caffe.Blob([]) bottom = [] top = [t] # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.data_layers" lp.python_param.layer = "HDF5Layer" lp.python_param.param_str = str(dict( batch_size=batch_size, source=lpath_source.strpath, path_h5=path_h5, column_id=0, blob_name='blob1')) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) j = 0 for i in xrange(3): layer.Reshape(bottom, top) layer.Forward(bottom, top) assert top[0].shape == (batch_size,) + blob_shape for blob in top[0].data: j %= n_sample assert np.all(blob == data[j].astype(np.float32)) j += 1 # Shuffle: Values are not checked here so far. lp.python_param.param_str = str(dict( batch_size=batch_size, source=lpath_source.strpath, path_h5=path_h5, column_id=0, blob_name='blob1', shuffle=True, random_seed=313)) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) for i in xrange(3): layer.Reshape(bottom, top) layer.Forward(bottom, top) assert top[0].shape == (batch_size,) + blob_shape
def matrix_mult_layer(request): if request.config.getoption('caffe_cpu'): raise pytest.skip("MatrixMultLayer requires GPU") m1 = caffe.Blob((2, 4, 2)) m2 = caffe.Blob((2, 2, 3)) t = caffe.Blob([]) t1, t2 = request.param if t1: s = m1.shape m1.reshape(s[0], s[2], s[1]) if t2: s = m2.shape m2.reshape(s[0], s[2], s[1]) rng = np.random.RandomState(313) m1.data[...] = rng.randn(*m1.shape) m2.data[...] = rng.randn(*m2.shape) bottom = [m1, m2] top = [t] # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.common_layers" lp.python_param.layer = "MatrixMultLayer" lp.python_param.param_str = str({'t1': t1, 't2': t2}) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) return layer, bottom, top, request.param
def test_morphology_layer(): ba, c, h, w = (2, 3, 4, 4) b = caffe.Blob([ba, c, h, w]) t = caffe.Blob([]) bottom = [b] top = [t] # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.vision_layers" lp.python_param.layer = "MorphologyLayer" lp.python_param.param_str = str(dict(op='erode', kernel='4nn')) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) b.data[1, ...] = [[ [0, 1, 1, 0], [1, 1, 1, 1], [1, 1, 1, 1], [0, 1, 1, 0], ]] layer.Reshape(bottom, top) layer.Forward(bottom, top) assert np.all(top[0].data[1, ...] == [[ [0, 0, 0, 0], [0, 1, 1, 0], [0, 1, 1, 0], [0, 0, 0, 0], ]])
def test_dssim_layer(request): if request.config.getoption('caffe_cpu'): raise pytest.skip("DSSIMLayer requires GPU") x, y = np.ogrid[:5, :5] img1 = np.sin(x / 5.0 * np.pi) * np.cos(y / 5.0 * np.pi) img1 = np.repeat(img1[..., np.newaxis], 3, 2) img1 = (img1 - img1.min()) / (img1.max() - img1.min()) rng = np.random.RandomState(313) img2 = img1 + rng.randn(*img1.shape) * 0.2 img2[img2 > 1] = 1 img2[img2 < 0] = 0 bottom = [caffe.Blob([]), caffe.Blob([])] top = [caffe.Blob([])] img1 = img1.transpose(2, 0, 1) img2 = img2.transpose(2, 0, 1) bottom[0].reshape(*((1,) + img1.shape)) bottom[1].reshape(*((1,) + img2.shape)) # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.loss_layers" lp.python_param.layer = "DSSIMLayer" lp.python_param.param_str = str({'hsize': 3}) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) bottom[0].data[...] = img1[np.newaxis] bottom[1].data[...] = img2[np.newaxis] checker = GradientChecker(1e-3, 1e-2) checker.check_gradient_exhaustive( layer, bottom, top, check_bottom=[0, 1])
def test_crossent_layer(request): if request.config.getoption('caffe_cpu'): raise pytest.skip("crossentropyLossLayer requires GPU") pred = caffe.Blob((5, 8)) label = caffe.Blob((5, 1)) loss = caffe.Blob([]) bottom = [pred, label] top = [loss] # Fill rng = np.random.RandomState(313) pred.data[...] = rng.rand(*pred.shape) + 0.1 label.data[...] = rng.randint(0, 8, label.shape) pred.data[...] = pred.data / pred.data.sum(axis=1, keepdims=True) # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.loss_layers" lp.python_param.layer = "CrossEntropyLossLayer" layer = caffe.create_layer(lp) layer.SetUp(bottom, top) layer.Reshape(bottom, top) layer.Forward(bottom, top) ref = -np.mean( np.log( np.maximum(np.finfo(np.float32).tiny, pred.data) ).reshape(pred.shape[0], -1)[ np.arange(pred.shape[0]), label.data.astype('int32')] ) assert np.isclose(ref, loss.data) checker = GradientChecker(1e-3, 1e-2) checker.check_gradient_exhaustive( layer, bottom, top, check_bottom=[0])
def test_slice_by_array_layer(blob_4_2322, tmpdir): path_indexes = tmpdir.join('indexes.mat').strpath from scipy.io import savemat indexes = np.array([2, 0]) savemat(path_indexes, {'indexes': indexes}) b, _, _, t = blob_4_2322 bottom = [b] top = [t] # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.common_layers" lp.python_param.layer = "SliceByArrayLayer" lp.python_param.param_str = str( {'path_mat': path_indexes, 'key': 'indexes'}) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) rng = np.random.RandomState(313) b.data[...] = rng.randn(*b.shape) layer.Reshape(bottom, top) layer.Forward(bottom, top) assert np.all(top[0].data == bottom[0].data[:, indexes, ...]) checker = GradientChecker(1e-2, 1e-5) checker.check_gradient_exhaustive( layer, bottom, top)
def test_graident_4_layer(): ba, c, h, w = (2, 3, 4, 4) b = caffe.Blob([ba, c, h, w]) t = caffe.Blob([]) bottom = [b] top = [t] # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.vision_layers" lp.python_param.layer = "Gradient4Layer" layer = caffe.create_layer(lp) layer.SetUp(bottom, top) rng = np.random.RandomState(313) b.data[...] = rng.randn(*b.shape) layer.Reshape(bottom, top) layer.Forward(bottom, top) assert top[0].shape == (ba, 2, c, h, w) assert np.all( top[0].data[:, 0, :, :, :-1] == bottom[0].data[..., :, :-1] - bottom[0].data[..., :, 1:]) assert np.all( top[0].data[:, 1, :, :-1, :] == bottom[0].data[..., :-1, :] - bottom[0].data[..., 1:, :]) checker = GradientChecker(1e-2, 1e-4) checker.check_gradient_exhaustive( layer, bottom, top)
def test_tile_layer(): ba, c, h, w = [2, 3, 3, 4] b, t = caffe.Blob([ba, c, h, w]), caffe.Blob([]) bottom = [b] top = [t] # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.common_layers" lp.python_param.layer = "TileLayer" axis = 1 num = 5 lp.python_param.param_str = str( {'axis': axis, 'num': num}) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) rng = np.random.RandomState(313) b.data[...] = rng.randn(*b.shape) layer.Reshape(bottom, top) layer.Forward(bottom, top) assert t.shape == (ba, c * num, h, w) reps = [1 for _ in t.shape] reps[axis] = num assert np.all(np.tile(b.data, reps) == t.data) checker = GradientChecker(1e-2, 1e-5) checker.check_gradient_exhaustive( layer, bottom, top)
def test_tile_layer(): ba, c, h, w = [2, 3, 3, 4] b, t = caffe.Blob([ba, c, h, w]), caffe.Blob([]) bottom = [b] top = [t] # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.common_layers" lp.python_param.layer = "TileLayer" axis = 1 num = 5 lp.python_param.param_str = str({'axis': axis, 'num': num}) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) rng = np.random.RandomState(313) b.data[...] = rng.randn(*b.shape) layer.Reshape(bottom, top) layer.Forward(bottom, top) assert t.shape == (ba, c * num, h, w) reps = [1 for _ in t.shape] reps[axis] = num assert np.all(np.tile(b.data, reps) == t.data) checker = GradientChecker(1e-2, 1e-5) checker.check_gradient_exhaustive(layer, bottom, top)
def test_logit_loss_layer(request): if request.config.getoption('caffe_cpu'): raise pytest.skip("LogitLossLayer requires GPU") # data y = np.random.rand(2, 3, 4, 5) t = (np.random.rand(2, 3, 4, 5) > 0.5).astype(np.float)\ - (np.random.rand(2, 3, 4, 5) > 0.5).astype(np.float) # setting up blobs bottom = [caffe.Blob([]), caffe.Blob([])] top = [caffe.Blob([])] bottom[0].reshape(*y.shape) bottom[1].reshape(*t.shape) bottom[0].data[...] = y bottom[1].data[...] = t # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.loss_layers" lp.python_param.layer = "LogitLossLayer" layer = caffe.create_layer(lp) layer.SetUp(bottom, top) layer.Reshape(bottom, top) layer.Forward(bottom, top) # reference computation l = np.sum(np.abs(t) * np.log(1 + np.exp(-y * t))) / np.sum(np.abs(t)) assert np.isclose(top[0].data, l) checker = GradientChecker(1e-3, 1e-2) checker.check_gradient_exhaustive( layer, bottom, top, check_bottom=[0])
def test_create_conv_layer(self): # Setting layer parameter for convolution layer_param = caffe_pb2.LayerParameter() layer_param.type = 'Convolution' layer_param.name = 'conv1' cparam = layer_param.convolution_param cparam.num_output = 3 cparam.kernel_size.append(2) wfiller = cparam.weight_filler wfiller.type = "uniform" wfiller.max = 3 wfiller.min = 1.5 # Create layer conv_layer = caffe.create_layer(layer_param) self.assertEqual(conv_layer.type, 'Convolution') # Set up layer conv_layer.SetUp([self.blobi], [self.blobo]) weights = conv_layer.blobs[0] self.assertTrue(np.all(weights.data >= 1.5)) self.assertTrue(np.all(weights.data <= 3.0)) # Reshape out blobs conv_layer.Reshape([self.blobi], [self.blobo]) shapei = self.shapei shapeo = self.blobo.data.shape self.assertEqual( shapeo, (shapei[0], cparam.num_output, shapei[2] - cparam.kernel_size[0] + 1, shapei[3] - cparam.kernel_size[0] + 1)) # Forward, Backward conv_layer.Forward([self.blobi], [self.blobo]) conv_layer.Backward([self.blobo], [True], [self.blobi])
def test_slice_by_array_layer(blob_4_2322, tmpdir): path_indexes = tmpdir.join('indexes.mat').strpath from scipy.io import savemat indexes = np.array([2, 0]) savemat(path_indexes, {'indexes': indexes}) b, _, _, t = blob_4_2322 bottom = [b] top = [t] # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.common_layers" lp.python_param.layer = "SliceByArrayLayer" lp.python_param.param_str = str({ 'path_mat': path_indexes, 'key': 'indexes' }) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) rng = np.random.RandomState(313) b.data[...] = rng.randn(*b.shape) layer.Reshape(bottom, top) layer.Forward(bottom, top) assert np.all(top[0].data == bottom[0].data[:, indexes, ...]) checker = GradientChecker(1e-2, 1e-5) checker.check_gradient_exhaustive(layer, bottom, top)
def test_create_conv_layer(self): # Setting layer parameter for convolution layer_param = caffe_pb2.LayerParameter() layer_param.type = 'Convolution' layer_param.name = 'conv1' cparam = layer_param.convolution_param cparam.num_output = 3 cparam.kernel_size = 2 wfiller = cparam.weight_filler wfiller.type = "uniform" wfiller.max = 3 wfiller.min = 1.5 # Create layer conv_layer = caffe.create_layer(layer_param) self.assertEqual(conv_layer.type, 'Convolution') # Set up layer conv_layer.SetUp([self.blobi], [self.blobo]) weights = conv_layer.blobs[0] self.assertTrue(np.all(weights.data >= 1.5)) self.assertTrue(np.all(weights.data <= 3.0)) # Reshape out blobs conv_layer.Reshape([self.blobi], [self.blobo]) shapei = self.shapei shapeo = self.blobo.data.shape self.assertEqual( shapeo, (shapei[0], cparam.num_output, shapei[2] - cparam.kernel_size + 1, shapei[3] - cparam.kernel_size + 1)) # Forward, Backward conv_layer.Forward([self.blobi], [self.blobo]) conv_layer.Backward([self.blobo], [True], [self.blobi])
def test_morphology_layer(): ba, c, h, w = (2, 3, 4, 4) b = caffe.Blob([ba, c, h, w]) t = caffe.Blob([]) bottom = [b] top = [t] # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.vision_layers" lp.python_param.layer = "MorphologyLayer" lp.python_param.param_str = str(dict(op='erode', kernel='4nn')) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) b.data[1, ...] = [[ [0, 1, 1, 0], [1, 1, 1, 1], [1, 1, 1, 1], [0, 1, 1, 0], ]] layer.Reshape(bottom, top) layer.Forward(bottom, top) assert np.all( top[0].data[1, ...] == [[ [0, 0, 0, 0], [0, 1, 1, 0], [0, 1, 1, 0], [0, 0, 0, 0], ]])
def upsample_creator(factor, num_in): kernel = get_kernel_size(factor) stride = factor lp = caffe.LayerParameter( """name: "upsample", type: "Deconvolution" convolution_param { kernel_size: %d stride: %d num_output: %d group: %d pad: %d weight_filler: { type: "bilinear_upsampling" } bias_term: false }""" % (kernel, stride, num_in, num_in, get_pad(factor))) return caffe.create_layer(lp.to_python())
def upsample_creator(factor, num_in): kernel = get_kernel_size(factor) stride = factor lp = caffe.LayerParameter("""name: "upsample", type: "Deconvolution" convolution_param { kernel_size: %d stride: %d num_output: %d group: %d pad: %d weight_filler: { type: "bilinear_upsampling" } bias_term: false }""" % ( kernel, stride, num_in, num_in, get_pad(factor) )) return caffe.create_layer(lp.to_python())
def test_mask_loss(self): lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module='mask_reg_layer.layer' lp.python_param.layer='MaskLossLayer' layer = caffe.create_layer(lp) checker = GradientChecker(1e-2, 1e-1) checker.check_gradient_exhaustive( layer, self.bottom, self.top, check_bottom=[0])
def view_sigmoid_output(self): net = self.solver.net lp = caffe_pb2.LayerParameter() lp.type = "Sigmoid" layer = caffe.create_layer(lp) bottom = [net.blobs['cls_score']] top = [caffe.Blob([])] labels = net.blobs['labels'].data layer.SetUp(bottom, top) layer.Reshape(bottom, top) layer.Forward(bottom, top) np.set_printoptions(precision=3, suppress=True) print("Sigmoid output v.s. Labels: ") print(np.c_[top[0].data, labels])
def test_euclidean(self): lp = caffe_pb2.LayerParameter() lp.type = "EuclideanLoss" layer = caffe.create_layer(lp) layer.SetUp(self.bottom, self.top) layer.Reshape(self.bottom, self.top) layer.Forward(self.bottom, self.top) # manual computation loss = np.sum((self.bottom[0].data - self.bottom[1].data) ** 2) \ / self.bottom[0].shape[0] / 2.0 self.assertAlmostEqual(float(self.top[0].data), loss, 5) checker = GradientChecker(1e-2, 1e-2) checker.check_gradient_exhaustive( layer, self.bottom, self.top, check_bottom='all')
def reshape_layer(blob_4_2322): b, _, _, t = blob_4_2322 t.reshape(*b.shape) bottom = [t] top = [t] reshape = (2, 12) # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.common_layers" lp.python_param.layer = "ReshapeLayer" lp.python_param.param_str = str({'shape': reshape}) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) return layer
def view_softmax_output(self): net = self.solver.net lp = caffe_pb2.LayerParameter() lp.type = "Softmax" layer = caffe.create_layer(lp) bottom = [net.blobs['cls_score']] top = [caffe.Blob([])] labels = net.blobs['labels'].data layer.SetUp(bottom, top) layer.Reshape(bottom, top) layer.Forward(bottom, top) np.set_printoptions(precision=3, suppress=True) print("Softmax output v.s. Labels: ") # print(np.sum(top[0].data,axis=1)) # print(np.sum(top[0].data,axis=0)) # print(top[0].data.shape) # print(np.c_[top[0].data, labels]) print(np.c_[np.argmax(top[0].data, axis=1), labels])
def test_reduction_layer_sum(blob_4_2322): b, _, _, t = blob_4_2322 bottom = [b] top = [t] # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.common_layers" lp.python_param.layer = "ReductionLayer" lp.python_param.param_str = str({'axis': 1, 'op': 'sum'}) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) rng = np.random.RandomState(313) b.data[...] = rng.randn(*b.shape) layer.Reshape(bottom, top) layer.Forward(bottom, top) assert np.all(b.data.sum(layer.axis_, keepdims=True) == t.data) checker = GradientChecker(1e-2, 1e-4) checker.check_gradient_exhaustive(layer, bottom, top)
def test_reduction_layer_sum(blob_4_2322): b, _, _, t = blob_4_2322 bottom = [b] top = [t] # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.common_layers" lp.python_param.layer = "ReductionLayer" lp.python_param.param_str = str({'axis': 1, 'op': 'sum'}) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) rng = np.random.RandomState(313) b.data[...] = rng.randn(*b.shape) layer.Reshape(bottom, top) layer.Forward(bottom, top) assert np.all(b.data.sum(layer.axis_, keepdims=True) == t.data) checker = GradientChecker(1e-2, 1e-4) checker.check_gradient_exhaustive( layer, bottom, top)
def sil2_loss_layer(request, blob_4_2322): if request.config.getoption('caffe_cpu'): raise pytest.skip("ScaleInvariantL2LossLayer requires GPU") print "Call:", request.fixturename # Create blobs pred, label, mask, top = blob_4_2322 bottom = [pred, label, mask] top = [top] lam = 0.5 # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.loss_layers" lp.python_param.layer = "ScaleInvariantL2LossLayer" lp.python_param.param_str = str({'lambda': lam}) # caffe.set_mode_gpu() # caffe.set_device(0) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) return layer
def test_inner_product(self): lp = caffe_pb2.LayerParameter() lp.type = "InnerProduct" lp.inner_product_param.num_output = 3 layer = caffe.create_layer(lp) layer.SetUp([self.bottom[0]], self.top) w = self.rng.randn(*layer.blobs[0].shape) b = self.rng.randn(*layer.blobs[1].shape) layer.blobs[0].data[...] = w layer.blobs[1].data[...] = b layer.Reshape([self.bottom[0]], self.top) layer.Forward([self.bottom[0]], self.top) assert np.allclose( self.top[0].data, np.dot( self.bottom[0].data.reshape(self.bottom[0].shape[0], -1), w.T ) + b ) checker = GradientChecker(1e-2, 1e-1) checker.check_gradient_exhaustive( layer, [self.bottom[0]], self.top, check_bottom=[0])
def test_parameter_layer(): t = caffe.Blob([]) bottom = [] top = [t] # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.common_layers" lp.python_param.layer = "ParameterLayer" lp.python_param.param_str = str( dict(shape=(2, 3, 2, 2), filler="lambda shape, rng: rng.randn(*shape) * 0.01")) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) assert len(layer.blobs) == 1 assert layer.blobs[0].shape == (2, 3, 2, 2) param_copy = layer.blobs[0].data.copy() layer.Forward(bottom, top) assert np.allclose(top[0].data, param_copy) checker = GradientChecker(1e-3, 1e-5) checker.check_gradient_exhaustive(layer, bottom, top)
def test_axpb_layer(blob_4_2322): b, _, _, t = blob_4_2322 bottom = [b] top = [t] # Create Layer va = 0.7 vb = -0.3 lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.common_layers" lp.python_param.layer = "AXPBLayer" lp.python_param.param_str = str({'a': va, 'b': vb}) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) rng = np.random.RandomState(313) b.data[...] = rng.randn(*b.shape) layer.Reshape(bottom, top) layer.Forward(bottom, top) assert np.all(va * b.data + vb == t.data) checker = GradientChecker(1e-3, 1e-2) checker.check_gradient_exhaustive(layer, bottom, top)
def test_broadcast_layer(): ba, c, h, w = [2, 1, 3, 4] b, t = caffe.Blob([ba, c, h, w]), caffe.Blob([]) bottom = [b] top = [t] # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.common_layers" lp.python_param.layer = "BroadcastLayer" lp.python_param.param_str = str({'axis': 1, 'num': 3}) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) rng = np.random.RandomState(313) b.data[...] = rng.randn(*b.shape) layer.Reshape(bottom, top) layer.Forward(bottom, top) assert t.shape == (ba, 3, h, w) for i in xrange(3): assert np.all(b.data == t.data[:, i:i + 1]) checker = GradientChecker(1e-2, 1e-5) checker.check_gradient_exhaustive(layer, bottom, top)
def test_parameter_layer(): t = caffe.Blob([]) bottom = [] top = [t] # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.common_layers" lp.python_param.layer = "ParameterLayer" lp.python_param.param_str = str(dict( shape=(2, 3, 2, 2), filler="lambda shape, rng: rng.randn(*shape) * 0.01")) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) assert len(layer.blobs) == 1 assert layer.blobs[0].shape == (2, 3, 2, 2) param_copy = layer.blobs[0].data.copy() layer.Forward(bottom, top) assert np.allclose(top[0].data, param_copy) checker = GradientChecker(1e-3, 1e-5) checker.check_gradient_exhaustive( layer, bottom, top)
def test_axpb_layer(blob_4_2322): b, _, _, t = blob_4_2322 bottom = [b] top = [t] # Create Layer va = 0.7 vb = -0.3 lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.common_layers" lp.python_param.layer = "AXPBLayer" lp.python_param.param_str = str({'a': va, 'b': vb}) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) rng = np.random.RandomState(313) b.data[...] = rng.randn(*b.shape) layer.Reshape(bottom, top) layer.Forward(bottom, top) assert np.all(va * b.data + vb == t.data) checker = GradientChecker(1e-3, 1e-2) checker.check_gradient_exhaustive( layer, bottom, top)
def test_SoftmaxLoss(self): net = self.solver.net #print(net.blobs.keys()) # for i in range(30): # print("shape @ {}: {}".format(i,net.blobs[i].shape)) # print(dir(net)) # print(len(net.blobs)) # print(dir(net.layer_dict['cls_score'])) # sys.exit() #print(net.layer_dict.keys()) lp = caffe_pb2.LayerParameter() lp.type = "Sigmoid" layer = caffe.create_layer(lp) data = net.blobs['cls_score'].data bottom = [caffe.Blob(data.shape)] bottom[0].data[...] = data top = [caffe.Blob([])] layer.SetUp(bottom, top) layer.Reshape(bottom, top) layer.Forward(bottom, top) print("data", data, "top[0].data", top[0].data) print(net.blobs['labels'].data - top[0].data)
def test_lp_normalization_layer(blob_4_2322, lpnorm_params): axis, p = lpnorm_params b, _, _, t = blob_4_2322 bottom = [b] top = [t] # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.common_layers" lp.python_param.layer = "LpNormalizationLayer" lp.python_param.param_str = str({'axis': axis, 'p': p}) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) rng = np.random.RandomState(313) b.data[...] = rng.rand(*b.shape) layer.Reshape(bottom, top) layer.Forward(bottom, top) if axis is None: axis = tuple(range(1, len(bottom[0].shape))) test_top = b.data / ((b.data**p).sum(axis, keepdims=True)**(1. / p)) assert np.allclose(test_top, t.data) checker = GradientChecker(1e-3, 1e-2) checker.check_gradient_exhaustive(layer, bottom, top)
def test_broadcast_layer(): ba, c, h, w = [2, 1, 3, 4] b, t = caffe.Blob([ba, c, h, w]), caffe.Blob([]) bottom = [b] top = [t] # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.common_layers" lp.python_param.layer = "BroadcastLayer" lp.python_param.param_str = str( {'axis': 1, 'num': 3}) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) rng = np.random.RandomState(313) b.data[...] = rng.randn(*b.shape) layer.Reshape(bottom, top) layer.Forward(bottom, top) assert t.shape == (ba, 3, h, w) for i in xrange(3): assert np.all(b.data == t.data[:, i:i + 1]) checker = GradientChecker(1e-2, 1e-5) checker.check_gradient_exhaustive( layer, bottom, top)
def test_lp_normalization_layer(blob_4_2322, lpnorm_params): axis, p = lpnorm_params b, _, _, t = blob_4_2322 bottom = [b] top = [t] # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.common_layers" lp.python_param.layer = "LpNormalizationLayer" lp.python_param.param_str = str({'axis': axis, 'p': p}) layer = caffe.create_layer(lp) layer.SetUp(bottom, top) rng = np.random.RandomState(313) b.data[...] = rng.rand(*b.shape) layer.Reshape(bottom, top) layer.Forward(bottom, top) if axis is None: axis = tuple(range(1, len(bottom[0].shape))) test_top = b.data / ((b.data**p).sum(axis, keepdims=True) ** (1./p)) assert np.allclose(test_top, t.data) checker = GradientChecker(1e-3, 1e-2) checker.check_gradient_exhaustive( layer, bottom, top)
def test_graident_4_layer(): ba, c, h, w = (2, 3, 4, 4) b = caffe.Blob([ba, c, h, w]) t = caffe.Blob([]) bottom = [b] top = [t] # Create Layer lp = caffe_pb2.LayerParameter() lp.type = "Python" lp.python_param.module = "caffe_helper.layers.vision_layers" lp.python_param.layer = "Gradient4Layer" layer = caffe.create_layer(lp) layer.SetUp(bottom, top) rng = np.random.RandomState(313) b.data[...] = rng.randn(*b.shape) layer.Reshape(bottom, top) layer.Forward(bottom, top) assert top[0].shape == (ba, 2, c, h, w) assert np.all(top[0].data[:, 0, :, :, :-1] == bottom[0].data[..., :, :-1] - bottom[0].data[..., :, 1:]) assert np.all(top[0].data[:, 1, :, :-1, :] == bottom[0].data[..., :-1, :] - bottom[0].data[..., 1:, :]) checker = GradientChecker(1e-2, 1e-4) checker.check_gradient_exhaustive(layer, bottom, top)