def _testSolver(self, solver):
# We are going to test if the solver correctly deals with the mpi case
# where multiple nodes host different data. To this end we will
# create a dummy regression problem which, when run under mpi with
# >1 nodes, will create a different result from a single-node run.
np.random.seed(1701)
X = base.Blob((10, 1),
filler=fillers.GaussianRandFiller(mean=mpi.RANK,
std=0.01))
Y = base.Blob((10, 1),
filler=fillers.ConstantFiller(value=mpi.RANK + 1.))
decaf_net = base.Net()
decaf_net.add_layer(core_layers.InnerProductLayer(name='ip',
num_output=1),
needs='X',
provides='pred')
decaf_net.add_layer(core_layers.SquaredLossLayer(name='loss'),
needs=['pred', 'Y'])
decaf_net.finish()
solver.solve(decaf_net, previous_net={'X': X, 'Y': Y})
w, b = decaf_net.layers['ip'].param()
print w.data(), b.data()
if mpi.SIZE == 1:
# If size is 1, we are fitting y = 0 * x + 1
np.testing.assert_array_almost_equal(w.data(), 0., 2)
np.testing.assert_array_almost_equal(b.data(), 1., 2)
else:
# if size is not 1, we are fitting y = x + 1
np.testing.assert_array_almost_equal(w.data(), 1., 2)
np.testing.assert_array_almost_equal(b.data(), 1., 2)
self.assertTrue(True)
def translate_cuda_network(cuda_layers, output_shapes):
"""Translates a list of cuda layers to a decaf net.
Input:
cuda_layers: a list of layers from the cuda convnet training.
output_shapes: a dictionary that contains the specification on the
input shapes. This dictionary will be modified in-place to add
the output shapes for the intermediate layers, but you need to
provide the shapes for all the data layers. For data that are
going to be scalar, use -1. The shapes should be following the
decaf convention, not the cuda convnet convention.
"""
decaf_net = base.Net()
for cuda_layer in cuda_layers:
decaf_layer = translate_layer(cuda_layer, output_shapes)
if not decaf_layer:
# This layer should be ignored.
continue
# Now, let's figure out the parent of the layer
needs = []
for idx in cuda_layer['inputs']:
if cuda_layers[idx]['type'] == DATA_TYPENAME:
needs.append(cuda_layers[idx]['name'])
else:
needs.append(cuda_layers[idx]['name'] + OUTPUT_AFFIX)
provide = cuda_layer['name'] + OUTPUT_AFFIX
decaf_net.add_layers(decaf_layer, needs=needs, provides=provide)
decaf_net.finish()
return decaf_net
def testForwardBackwardWithPrevLayer(self):
decaf_net = base.Net()
prev_net = base.Net()
# add data layer
prev_net.add_layers(imagenet_data(),
provides=['image', 'label'])
decaf_net.add_layers(imagenet_layers(),
needs='image',
provides='prediction')
loss_layer = core_layers.MultinomialLogisticLossLayer(
name='loss')
decaf_net.add_layer(loss_layer,
needs=['prediction', 'label'])
prev_net.finish()
decaf_net.finish()
loss = decaf_net.forward_backward(previous_net=prev_net)
self.assertGreater(loss, 0.)
self.assertLess(loss, 10.)
def testPredict(self):
# testPredict tests performing prediction without loss layer.
decaf_net = base.Net()
# add data layer
decaf_net.add_layers(imagenet_data(),
provides=['image', 'label'])
decaf_net.add_layers(imagenet_layers(),
needs='image',
provides='prediction')
decaf_net.finish()
result = decaf_net.predict()
self.assertTrue('label' in result)
self.assertTrue('prediction' in result)
self.assertEqual(result['prediction'].shape[-1], 1000)
def testForwardBackward(self):
# testForwardBackward tests the full f-b path.
decaf_net = base.Net()
# add data layer
decaf_net.add_layers(imagenet_data(),
provides=['image', 'label'])
decaf_net.add_layers(imagenet_layers(),
needs='image',
provides='prediction')
loss_layer = core_layers.MultinomialLogisticLossLayer(
name='loss')
decaf_net.add_layer(loss_layer,
needs=['prediction', 'label'])
decaf_net.finish()
loss = decaf_net.forward_backward()
self.assertGreater(loss, 0.)
self.assertLess(loss, 10.)
def setUp(self):
self.decaf_net = base.Net()
self.decaf_net.add_layer(base.Layer(name='a'), provides='data')
self.decaf_net.add_layer(base.Layer(name='b'), needs='data')
self.decaf_net.add_layer(base.Layer(name='c'), needs='data')
self.decaf_net.finish()
def main():
logging.getLogger().setLevel(logging.INFO)
######################################
# First, let's create the decaf layer.
######################################
logging.info('Loading data and creating the network...')
decaf_net = base.Net()
# add data layer
dataset = mnist.MNISTDataLayer(name='mnist',
rootfolder=ROOT_FOLDER,
is_training=True)
decaf_net.add_layer(dataset, provides=['image-all', 'label-all'])
# add minibatch layer for stochastic optimization
minibatch_layer = core_layers.BasicMinibatchLayer(name='batch',
minibatch=MINIBATCH)
decaf_net.add_layer(minibatch_layer,
needs=['image-all', 'label-all'],
provides=['image', 'label'])
# add the two_layer network
decaf_net.add_layers([
core_layers.FlattenLayer(name='flatten'),
core_layers.InnerProductLayer(
name='ip1',
num_output=NUM_NEURONS,
filler=fillers.GaussianRandFiller(std=0.1),
bias_filler=fillers.ConstantFiller(value=0.1)),
core_layers.ReLULayer(name='relu1'),
core_layers.InnerProductLayer(
name='ip2',
num_output=NUM_CLASS,
filler=fillers.GaussianRandFiller(std=0.3))
],
needs='image',
provides='prediction')
# add loss layer
loss_layer = core_layers.MultinomialLogisticLossLayer(name='loss')
decaf_net.add_layer(loss_layer, needs=['prediction', 'label'])
# finish.
decaf_net.finish()
####################################
# Decaf layer finished construction!
####################################
# now, try to solve it
if METHOD == 'adagrad':
# The Adagrad Solver
solver = core_solvers.AdagradSolver(base_lr=0.02,
base_accum=1.e-6,
max_iter=1000)
elif METHOD == 'sgd':
solver = core_solvers.SGDSolver(base_lr=0.1,
lr_policy='inv',
gamma=0.001,
power=0.75,
momentum=0.9,
max_iter=1000)
solver.solve(decaf_net)
visualize.draw_net_to_file(decaf_net, 'mnist.png')
decaf_net.save('mnist_2layers.decafnet')
##############################################
# Now, let's load the net and run predictions
##############################################
prediction_net = base.Net.load('mnist_2layers.decafnet')
visualize.draw_net_to_file(prediction_net, 'mnist_test.png')
# obtain the test data.
dataset_test = mnist.MNISTDataLayer(name='mnist',
rootfolder=ROOT_FOLDER,
is_training=False)
test_image = base.Blob()
test_label = base.Blob()
dataset_test.forward([], [test_image, test_label])
# Run the net.
pred = prediction_net.predict(image=test_image)['prediction']
accuracy = (pred.argmax(1) == test_label.data()).sum() / float(
test_label.data().size)
print 'Testing accuracy:', accuracy
print 'Done.'