def RunningAllreduceWithGPUs(self, gpu_ids, allreduce_function):
"""A base function to test different scenarios."""
workspace.ResetWorkspace()
net = core.Net("mujitest")
for id in gpu_ids:
net.ConstantFill([],
"testblob_gpu_" + str(id),
shape=[1, 2, 3, 4],
value=float(id + 1),
device_option=muji.OnGPU(id))
allreduce_function(net, ["testblob_gpu_" + str(i) for i in gpu_ids],
"_reduced", gpu_ids)
workspace.RunNetOnce(net)
target_value = sum(gpu_ids) + len(gpu_ids)
all_blobs = workspace.Blobs()
all_blobs.sort()
for blob in all_blobs:
print blob, workspace.FetchBlob(blob)
for id in gpu_ids:
blob = workspace.FetchBlob("testblob_gpu_" + str(i) + "_reduced")
np.testing.assert_array_equal(blob,
target_value,
err_msg="gpu id %d of %s" %
(id, str(gpu_ids)))
def testCreateWorkspace(self):
workspaces = workspace.Workspaces()
self.assertEqual(len(workspaces), 1)
self.assertEqual(workspaces[0], "default")
self.net = core.Net("test-net")
self.net.ConstantFill([], "testblob", shape=[1, 2, 3, 4], value=1.0)
self.assertEqual(
workspace.RunNetOnce(self.net.Proto().SerializeToString()), True)
self.assertEqual(workspace.HasBlob("testblob"), True)
self.assertEqual(workspace.SwitchWorkspace("test", True), True)
self.assertEqual(workspace.HasBlob("testblob"), False)
self.assertEqual(workspace.SwitchWorkspace("default"), True)
self.assertEqual(workspace.HasBlob("testblob"), True)
try:
# The following should raise an error.
workspace.SwitchWorkspace("non-existing")
# so this should never happen.
self.assertEqual(True, False)
except RuntimeError:
pass
workspaces = workspace.Workspaces()
self.assertEqual(len(workspaces), 2)
workspaces.sort()
self.assertEqual(workspaces[0], "default")
self.assertEqual(workspaces[1], "test")
def CheckNet(self, net, inputs={}, ignore=set()):
"""Checks a network by inspecting all of its intermediate results, and see
if things match.
"""
old_ws_name = workspace.CurrentWorkspace()
results = []
blobs_to_check = sum([list(op.outputs) for op in net.operators], [])
blobs_to_check = [b for b in blobs_to_check if b not in ignore]
workspace.SwitchWorkspace("_device_check_", True)
for i, device_option in enumerate(self._device_options):
for name, arr in inputs.iteritems():
workspace.FeedBlob(name, arr, device_option)
for op in net.operators:
op.device_option.CopyFrom(device_option)
workspace.RunNetOnce(net)
results.append(
[workspace.FetchBlob(name) for name in blobs_to_check])
# After running on all devices, check correctness
success = True
for i in range(1, len(results)):
for j in range(len(blobs_to_check)):
x = results[i][j]
y = results[0][j]
if np.any(np.abs(x - y) > self._threshold):
print 'Failure in checking device option', i, 'and blob ',
print blobs_to_check[j], '. The outputs are:'
print x.flatten()
print y.flatten()
success = False
continue
workspace.SwitchWorkspace(old_ws_name)
return success
def _testMiniAlexNet(self, order):
# First, we get all the random initialization of parameters.
model = self._MiniAlexNetNoDropout(order)
workspace.ResetWorkspace()
workspace.RunNetOnce(model.param_init_net)
inputs = dict([(str(name), workspace.FetchBlob(str(name)))
for name in model.params])
if order == "NCHW":
inputs["data"] = np.random.rand(4, 3, 227, 227).astype(np.float32)
else:
inputs["data"] = np.random.rand(4, 227, 227, 3).astype(np.float32)
inputs["label"] = np.array([1, 2, 3, 4]).astype(np.int32)
cpu_device = caffe2_pb2.DeviceOption()
cpu_device.device_type = caffe2_pb2.CPU
gpu_device = caffe2_pb2.DeviceOption()
gpu_device.device_type = caffe2_pb2.CUDA
checker = device_checker.DeviceChecker(1e-5, [cpu_device, gpu_device])
ret = checker.CheckNet(
model.net.Proto(),
inputs,
# The indices sometimes may be sensitive to small numerical differences
# in the input, so we ignore checking them.
ignore=['_pool1_idx', '_pool2_idx', '_pool5_idx'])
self.assertEqual(ret, True)
def testFetchBlobGPU(self):
self.assertEqual(workspace.RunNetOnce(self.net.Proto().SerializeToString()), True)
fetched = workspace.FetchBlob("testblob")
# check if fetched is correct.
self.assertEqual(fetched.shape, (1, 2, 3, 4))
np.testing.assert_array_equal(fetched, 1.0)
fetched[:] = 2.0
self.assertEqual(workspace.FeedBlob("testblob", fetched), True)
fetched_again = workspace.FetchBlob("testblob")
self.assertEqual(fetched_again.shape, (1, 2, 3, 4))
np.testing.assert_array_equal(fetched_again, 2.0)
def testMNISTNetworks(self):
# First, we get all the random initialization of parameters.
init_net, train_net = self._MNISTNetworks()
workspace.ResetWorkspace()
workspace.RunNetOnce(init_net)
inputs = dict([(str(name), workspace.FetchBlob(str(name)))
for name in workspace.Blobs()])
cpu_device = caffe2_pb2.DeviceOption()
cpu_device.device_type = caffe2_pb2.CPU
gpu_device = caffe2_pb2.DeviceOption()
gpu_device.device_type = caffe2_pb2.CUDA
checker = device_checker.DeviceChecker(1e-2, [cpu_device, gpu_device])
ret = checker.CheckNet(train_net.Proto(), inputs)
self.assertEqual(ret, True)
def Benchmark(model_gen, arg):
model, input_size = model_gen(arg.order)
# In order to be able to run everything without feeding more stuff, let's
# add the data and label blobs to the parameter initialization net as well.
if arg.order == "NCHW":
input_shape = [arg.batch_size, 3, input_size, input_size]
else:
input_shape = [arg.batch_size, input_size, input_size, 3]
model.param_init_net.GaussianFill([],
"data",
shape=input_shape,
mean=0.0,
std=1.0)
model.param_init_net.UniformIntFill([],
"label",
shape=[
arg.batch_size,
],
min=0,
max=999)
# Note: even when we are running things on CPU, adding a few engine related
# argument will not hurt since the CPU operator registy will simply ignore
# these options and go the default path.
for op in model.net.Proto().op:
if op.type == 'Conv' or op.type == 'ConvFp16':
op.engine = 'CUDNN'
#op.arg.add().CopyFrom(utils.MakeArgument('ws_nbytes_limit', arg.cudnn_limit))
op.arg.add().CopyFrom(utils.MakeArgument('exhaustive_search', 1))
op.arg.add().CopyFrom(
utils.MakeArgument('shared_ws_name', 'cudnn_workspace'))
elif op.type in [
'MaxPool', 'MaxPoolFp16', 'AveragePool', 'AveragePoolFp16',
'Relu', 'ReluFp16', 'Softmax', 'SoftmaxFp16'
]:
op.engine = 'CUDNN'
if arg.forward_only:
print arg.model, ': running forward only.'
else:
print arg.model, ': running forward-backward.'
model.AddGradientOperators()
if arg.order == 'NHWC':
print(
'==WARNING==\n'
'NHWC order with CuDNN may not be supported yet, so I might\n'
'exit suddenly.')
if not arg.cpu:
model.param_init_net.RunAllOnGPU()
model.net.RunAllOnGPU()
workspace.RunNetOnce(model.param_init_net)
workspace.CreateNet(model.net)
for i in range(arg.warmup_iterations):
workspace.RunNet(model.net.Proto().name)
start = time.time()
for i in range(arg.iterations):
workspace.RunNet(model.net.Proto().name)
print 'Spent: ', (time.time() - start) / arg.iterations
if arg.layer_wise_benchmark:
print 'Layer-wise benchmark.'
workspace.BenchmarkNet(model.net.Proto().name, 1, arg.iterations, True)
# Writes out the pbtxt for benchmarks on e.g. Android
with open("{0}_init_batch_{1}.pbtxt".format(arg.model, arg.batch_size),
"w") as fid:
fid.write(str(model.param_init_net.Proto()))
with open("{0}.pbtxt".format(arg.model, arg.batch_size), "w") as fid:
fid.write(str(model.net.Proto()))
if __name__ == '__main__':
if len(sys.argv) == 1:
print(
'If you do not explicitly ask to run this test, I will not run it. '
'Pass in any argument to have the test run for you.')
sys.exit(0)
if not os.path.exists('data/testdata/caffe_translator'):
print 'No testdata existing for the caffe translator test. Exiting.'
sys.exit(0)
# We will do all the computation stuff in the global space.
caffenet = caffe_pb2.NetParameter()
caffenet_pretrained = caffe_pb2.NetParameter()
text_format.Merge(
open('data/testdata/caffe_translator/deploy.prototxt').read(),
caffenet)
caffenet_pretrained.ParseFromString(
open(
'data/testdata/caffe_translator/bvlc_reference_caffenet.caffemodel'
).read())
net, pretrained_params = caffe_translator.TranslateModel(
caffenet, caffenet_pretrained)
caffe_translator.DeleteDropout(net)
for param in pretrained_params.protos:
workspace.FeedBlob(param.name, utils.Caffe2TensorToNumpyArray(param))
# Let's also feed in the data from the Caffe test code.
data = np.load('data/testdata/caffe_translator/data_dump.npy').astype(
np.float32)
workspace.FeedBlob('data', data)
# Actually running the test.
workspace.RunNetOnce(net.SerializeToString())
unittest.main()
def testResetWorkspace(self):
self.assertEqual(workspace.RunNetOnce(self.net.Proto().SerializeToString()), True)
self.assertEqual(workspace.HasBlob("testblob"), True)
self.assertEqual(workspace.ResetWorkspace(), True)
self.assertEqual(workspace.HasBlob("testblob"), False)
