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 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.'
"""
from decaf import base
from decaf.util import smalldata
from decaf.layers import convolution, fillers
import numpy as np
from skimage import io
"""The main demo code."""
img = np.asarray(smalldata.lena())
img = img.reshape((1, ) + img.shape).astype(np.float64)
# wrap the img in a blob
input_blob = base.Blob()
input_blob.mirror(img)
# create a convolutional layer
layer = convolution.ConvolutionLayer(
name='convolution',
num_kernels=1,
ksize=15,
stride=1,
mode='same',
filler=fillers.ConstantFiller(value=1. / 15 / 15 / 3))
# run the layer
output_blob = base.Blob()
layer.forward([input_blob], [output_blob])
out = np.multiply(output_blob.data()[0, :, :, 0], 256).astype(np.uint8)
io.imsave('out.png', out)
print('Convolution result written to out.png')