def testKLDivergenceLossGrad(self):
np.random.seed(1701)
layer = core_layers.KLDivergenceLossLayer(name='loss')
checker = gradcheck.GradChecker(1e-6)
shape = (4, 5)
# For the input, we make sure it is not too close to 0 (which would
# create numerical issues).
input_blob = base.Blob(shape,
filler=fillers.RandFiller(min=0.1, max=0.9))
# normalize input blob
input_data = input_blob.data()
input_data /= input_data.sum(1)[:, np.newaxis]
# check index input
target_blob = base.Blob(shape[:1],
dtype=np.int,
filler=fillers.RandIntFiller(high=shape[1]))
result = checker.check(layer, [input_blob, target_blob], [],
check_indices=[0])
print(result)
self.assertTrue(result[0])
# also, check if weight works.
self._testWeight(layer, [input_blob, target_blob])
# check full input
target_blob = base.Blob(shape, filler=fillers.RandFiller())
# normalize target
target_data = target_blob.data()
target_data /= target_data.sum(1)[:, np.newaxis]
result = checker.check(layer, [input_blob, target_blob], [],
check_indices=[0])
print(result)
self.assertTrue(result[0])
# also, check if weight works.
self._testWeight(layer, [input_blob, target_blob])
def testMultinomialLogisticLossGrad(self):
np.random.seed(1701)
layer = core_layers.MultinomialLogisticLossLayer(name='loss')
checker = gradcheck.GradChecker(1e-6)
shape = (10, 5)
# check index input
input_blob = base.Blob(shape, filler=fillers.GaussianRandFiller())
target_blob = base.Blob(shape[:1],
dtype=np.int,
filler=fillers.RandIntFiller(high=shape[1]))
result = checker.check(layer, [input_blob, target_blob], [],
check_indices=[0])
print(result)
self.assertTrue(result[0])
# also, check if weight works.
self._testWeight(layer, [input_blob, target_blob])
# check full input
target_blob = base.Blob(shape, filler=fillers.RandFiller())
# normalize target
target_data = target_blob.data()
target_data /= target_data.sum(1)[:, np.newaxis]
result = checker.check(layer, [input_blob, target_blob], [],
check_indices=[0])
print(result)
self.assertTrue(result[0])
# also, check if weight works.
self._testWeight(layer, [input_blob, target_blob])
def testGroupConvolutionGrad(self):
np.random.seed(1701)
output_blob = base.Blob()
checker = gradcheck.GradChecker(1e-3)
shapes = [(1, 5, 5, 4)]
num_kernels = 1
group = 2
params = [(3, 1, 'valid'), (3, 1, 'same'), (3, 1, 'full'),
(2, 1, 'valid'), (2, 1, 'full'), (3, 2, 'valid'),
(3, 2, 'same'), (3, 2, 'full')]
for shape in shapes:
for ksize, stride, mode in params:
print(ksize, stride, mode, shape)
input_blob = base.Blob(shape,
filler=fillers.GaussianRandFiller())
layer = core_layers.GroupConvolutionLayer(
name='gconv',
ksize=ksize,
stride=stride,
mode=mode,
num_kernels=num_kernels,
group=group,
filler=fillers.GaussianRandFiller())
result = checker.check(layer, [input_blob], [output_blob])
self.assertEqual(output_blob.data().shape[-1],
num_kernels * group)
print(result)
self.assertTrue(result[0])
# check if we will be able to produce an exception
input_blob = base.Blob((1, 5, 5, 3),
filler=fillers.GaussianRandFiller())
self.assertRaises(RuntimeError, checker.check, layer, [input_blob],
[output_blob])
def testLocalResponseNormalizeLayer(self):
np.random.seed(1701)
output_blob = base.Blob()
checker = gradcheck.GradChecker(1e-6)
shapes = [(1,10), (5,10)]
alphas = [1.0, 2.0]
betas = [0.75, 1.0]
for shape in shapes:
for alpha in alphas:
for beta in betas:
input_blob = base.Blob(shape, filler=fillers.RandFiller())
# odd size
layer = core_layers.LocalResponseNormalizeLayer(
name='normalize', k = 1., alpha=alpha, beta=beta, size=5)
result = checker.check(layer, [input_blob], [output_blob])
print(result)
self.assertTrue(result[0])
layer = core_layers.LocalResponseNormalizeLayer(
name='normalize', k = 2., alpha=alpha, beta=beta, size=5)
result = checker.check(layer, [input_blob], [output_blob])
print(result)
self.assertTrue(result[0])
# even size
layer = core_layers.LocalResponseNormalizeLayer(
name='normalize', k = 1., alpha=alpha, beta=beta, size=6)
result = checker.check(layer, [input_blob], [output_blob])
print(result)
self.assertTrue(result[0])
def testReLUGrad(self):
np.random.seed(1701)
shapes = [(4, 3), (1, 10), (2, 5, 5, 1), (2, 5, 5, 3)]
output_blob = base.Blob()
layer = core_layers.ReLULayer(name='relu')
checker = gradcheck.GradChecker(1e-5)
for shape in shapes:
input_blob = base.Blob(shape, filler=fillers.GaussianRandFiller())
result = checker.check(layer, [input_blob], [output_blob])
print(result)
self.assertTrue(result[0])
def testDropoutGrad(self):
np.random.seed(1701)
input_blob = base.Blob((4, 3), filler=fillers.GaussianRandFiller())
output_blob = base.Blob()
checker = gradcheck.GradChecker(1e-5)
layer = core_layers.DropoutLayer(name='dropout',
ratio=0.5,
debug_freeze=True)
result = checker.check(layer, [input_blob], [output_blob])
print(result)
self.assertTrue(result[0])
def testSplitGrad(self):
np.random.seed(1701)
output_blobs = [base.Blob(), base.Blob()]
checker = gradcheck.GradChecker(1e-5)
shapes = [(5, 4), (5, 1), (1, 5), (1, 5, 5), (1, 5, 5, 3),
(1, 5, 5, 1)]
for shape in shapes:
input_blob = base.Blob(shape, filler=fillers.GaussianRandFiller())
layer = base.SplitLayer(name='split')
result = checker.check(layer, [input_blob], output_blobs)
print(result)
self.assertTrue(result[0])
def testMeanNormalizeLayer(self):
np.random.seed(1701)
output_blob = base.Blob()
checker = gradcheck.GradChecker(1e-5)
shapes = [(1,5,5,1), (1,5,5,3), (5,5), (1,5)]
for shape in shapes:
input_blob = base.Blob(shape, filler=fillers.GaussianRandFiller())
layer = core_layers.MeanNormalizeLayer(
name='normalize')
result = checker.check(layer, [input_blob], [output_blob])
print(result)
self.assertTrue(result[0])
def testPaddingGrad(self):
np.random.seed(1701)
output_blob = base.Blob()
checker = gradcheck.GradChecker(1e-5)
shapes = [(1, 5, 5, 1), (1, 5, 5, 3), (1, 4, 3, 1), (1, 4, 3, 3)]
pads = [1, 2, 3]
for pad in pads:
for shape in shapes:
input_blob = base.Blob(shape,
filler=fillers.GaussianRandFiller())
layer = core_layers.PaddingLayer(name='padding', pad=pad)
result = checker.check(layer, [input_blob], [output_blob])
print(result)
self.assertTrue(result[0])
def testSoftmaxGrad(self):
np.random.seed(1701)
input_blob = base.Blob((10,5), filler=fillers.GaussianRandFiller())
output_blob = base.Blob()
layer = core_layers.SoftmaxLayer(name='softmax')
checker = gradcheck.GradChecker(1e-5)
result = checker.check(layer, [input_blob], [output_blob])
print(result)
self.assertTrue(result[0])
# Also, let's check the result
pred = input_blob.data()
prob = np.exp(pred) / np.exp(pred).sum(1)[:, np.newaxis]
np.testing.assert_array_almost_equal(
output_blob.data(), prob)
def testAutoencoderLossGrad(self):
np.random.seed(1701)
shapes = [(4, 3), (1, 10), (4, 3, 2)]
layer = core_layers.AutoencoderLossLayer(name='loss', ratio=0.5)
checker = gradcheck.GradChecker(1e-5)
for shape in shapes:
input_blob = base.Blob(shape,
filler=fillers.RandFiller(min=0.05,
max=0.95))
result = checker.check(layer, [input_blob], [])
print(result)
self.assertTrue(result[0])
# also, check if weight works.
self._testWeight(layer, [input_blob])
def testLogisticLossGrad(self):
np.random.seed(1701)
layer = core_layers.LogisticLossLayer(name='logistic')
checker = gradcheck.GradChecker(1e-6)
input_blob = base.Blob((10, 1), filler=fillers.GaussianRandFiller())
target_blob = base.Blob((10, ),
dtype=np.int,
filler=fillers.RandIntFiller(high=2))
result = checker.check(layer, [input_blob, target_blob], [],
check_indices=[0])
print(result)
self.assertTrue(result[0])
# also, check if weight works.
self._testWeight(layer, [input_blob, target_blob])
def testSquaredLossGrad(self):
np.random.seed(1701)
shapes = [(4, 3), (1, 10), (4, 3, 2)]
layer = core_layers.SquaredLossLayer(name='squared')
checker = gradcheck.GradChecker(1e-6)
for shape in shapes:
input_blob = base.Blob(shape, filler=fillers.GaussianRandFiller())
target_blob = base.Blob(shape, filler=fillers.GaussianRandFiller())
result = checker.check(layer, [input_blob, target_blob], [],
check_indices=[0])
print(result)
self.assertTrue(result[0])
# also, check if weight works.
self._testWeight(layer, [input_blob, target_blob])
def testIm2colGrad(self):
np.random.seed(1701)
output_blob = base.Blob()
checker = gradcheck.GradChecker(1e-4)
shapes = [(1, 5, 5, 1), (1, 5, 5, 3), (1, 4, 3, 1), (1, 4, 3, 3)]
params = [(2, 1), (2, 2), (3, 1), (3, 2)]
for psize, stride in params:
for shape in shapes:
input_blob = base.Blob(shape,
filler=fillers.GaussianRandFiller())
layer = core_layers.Im2colLayer(name='im2col',
psize=psize,
stride=stride)
result = checker.check(layer, [input_blob], [output_blob])
print(result)
self.assertTrue(result[0])
def testConvolutionGrad(self):
np.random.seed(1701)
output_blob = base.Blob()
checker = gradcheck.GradChecker(1e-4)
shapes = [(1,5,5,1), (1,5,5,3)]
num_kernels = 2
params = [(3,1,'valid'), (3,1,'same'), (3,1,'full'), (2,1,'valid'), (2,1,'full'),
(3,2,'valid'), (3,2,'same'), (3,2,'full')]
for shape in shapes:
for ksize, stride, mode in params:
print(ksize, stride, mode, shape)
input_blob = base.Blob(shape, filler=fillers.GaussianRandFiller())
layer = core_layers.ConvolutionLayer(
name='conv', ksize=ksize, stride=stride, mode=mode,
num_kernels=num_kernels,
filler=fillers.GaussianRandFiller())
result = checker.check(layer, [input_blob], [output_blob])
print(result)
self.assertTrue(result[0])
def testPoolingGrad(self):
np.random.seed(1701)
output_blob = base.Blob()
checker = gradcheck.GradChecker(1e-4)
shapes = [(1, 7, 7, 1), (2, 7, 7, 1), (1, 7, 7, 3), (1, 8, 8, 3),
(1, 13, 13, 1), (1, 13, 13, 2)]
params = [(3, 2, 'max'), (3, 2, 'ave'), (3, 3, 'max'), (3, 3, 'ave'),
(5, 3, 'max'), (5, 3, 'ave'), (5, 5, 'max'), (5, 5, 'ave')]
for shape in shapes:
for psize, stride, mode in params:
print(psize, stride, mode, shape)
input_blob = base.Blob(shape,
filler=fillers.GaussianRandFiller())
layer = core_layers.PoolingLayer(name='pool',
psize=psize,
stride=stride,
mode=mode)
result = checker.check(layer, [input_blob], [output_blob])
print(result)
self.assertTrue(result[0])
def testInnerproductGrad(self):
np.random.seed(1701)
input_blob = base.Blob((4, 3), filler=fillers.GaussianRandFiller())
output_blob = base.Blob()
checker = gradcheck.GradChecker(1e-5)
ip_layer = core_layers.InnerProductLayer(
name='ip',
num_output=5,
bias=True,
filler=fillers.GaussianRandFiller(),
bias_filler=fillers.GaussianRandFiller(),
reg=None)
result = checker.check(ip_layer, [input_blob], [output_blob])
print(result)
self.assertTrue(result[0])
ip_layer = core_layers.InnerProductLayer(
name='ip',
num_output=5,
bias=False,
filler=fillers.GaussianRandFiller(),
reg=None)
result = checker.check(ip_layer, [input_blob], [output_blob])
print(result)
self.assertTrue(result[0])
ip_layer = core_layers.InnerProductLayer(
name='ip',
num_output=5,
bias=True,
filler=fillers.GaussianRandFiller(),
bias_filler=fillers.GaussianRandFiller(),
reg=regularization.L2Regularizer(weight=0.1))
result = checker.check(ip_layer, [input_blob], [output_blob])
print(result)
self.assertTrue(result[0])
