def testVisualize(self):
from decaf.util import visualize
try:
import pydot
visualize.draw_net_to_file(self.decaf_net, tempfile.mktemp('.png'))
except (ImportError, pydot.InvocationException):
raise unittest.SkipTest(
'pydot not configured correctly. Skipping test.')
self.assertTrue(True)
def testVisualize(self):
from decaf.util import visualize
try:
import pydot
visualize.draw_net_to_file(self.decaf_net, tempfile.mktemp('.png'))
except (ImportError, pydot.InvocationException):
raise unittest.SkipTest(
'pydot not configured correctly. Skipping test.')
self.assertTrue(True)
def main():
"""A simple demo showing how to run decafnet."""
from decaf.util import smalldata, visualize
logging.getLogger().setLevel(logging.INFO)
net = DecafNet()
lena = smalldata.lena()
scores = net.classify(lena)
print 'prediction:', net.top_k_prediction(scores, 5)
visualize.draw_net_to_file(net._net, 'decafnet.png')
print 'Network structure written to decafnet.png'
def main():
"""A simple demo showing how to run jeffnet."""
from decaf.util import smalldata, visualize
logging.getLogger().setLevel(logging.INFO)
net = JeffNet()
lena = smalldata.lena()
scores = net.classify(lena)
print 'prediction:', net.top_k_prediction(scores, 5)
visualize.draw_net_to_file(net._net, 'jeffnet.png')
print 'Network structure written to jeffnet.png'
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.'
provides='ip2-out')
# The second sigmoid layer
decaf_net.add_layer(
core_layers.SigmoidLayer(name='sigmoid2'),
needs='ip2-out',
provides='sigmoid2-out')
# The reconstruction loss function
decaf_net.add_layer(
core_layers.SquaredLossLayer(name='loss'),
needs=['sigmoid2-out', 'patches-flatten'])
# Finished running decaf_net.
decaf_net.finish()
# let's do a proof-of-concept run, and draw the graph network to file.
decaf_net.forward_backward()
visualize.draw_net_to_file(decaf_net, 'sparse-autoencoder-structure.png')
#############################################
# The optimization.
#############################################
logging.info('*** Calling LBFGS solver ***')
solver = core_solvers.LBFGSSolver(
lbfgs_args={'maxfun': MAXFUN, 'disp': 1})
solver.solve(decaf_net)
# let's get the weight matrix and show it.
weight = decaf_net.layers['ip'].param()[0].data()
#visualize.show_multiple(weight.T)
decaf_net.save('sparse-autoencoder.decafnet')
#pyplot.show()
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.'
