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)
Beispiel #3
0
def test_sil2_loss_layer_backward(sil2_loss_layer, blob_4_2322_init):
    layer = sil2_loss_layer
    pred, label, mask, top = blob_4_2322_init
    bottom = [pred, label, mask]
    top = [top]
    checker = GradientChecker(1e-2, 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_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_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_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_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_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_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_sil2_loss_layer_backward(sil2_loss_layer, blob_4_2322_init):
    layer = sil2_loss_layer
    pred, label, mask, top = blob_4_2322_init
    bottom = [pred, label, mask]
    top = [top]
    checker = GradientChecker(1e-2, 1e-2)
    checker.check_gradient_exhaustive(
        layer, bottom, top, check_bottom=[0, 1])
 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 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 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_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_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_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_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_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)
Beispiel #22
0
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_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_matrix_mult_layer_backward(matrix_mult_layer):
    layer, bottom, top, _ = matrix_mult_layer
    checker = GradientChecker(1e-3, 1e-2)
    checker.check_gradient_exhaustive(layer, bottom, top)
def test_matrix_mult_layer_backward(matrix_mult_layer):
    layer, bottom, top, _ = matrix_mult_layer
    checker = GradientChecker(1e-3, 1e-2)
    checker.check_gradient_exhaustive(
        layer, bottom, top)