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')