def test_createdescriptorforconcatenation_wrong_shape_for_axis():
input_shape_vector = [ann.TensorShape((1, 2)), ann.TensorShape((3, 4)), ann.TensorShape((5, 6))]
with pytest.raises(RuntimeError) as err:
desc = ann.CreateDescriptorForConcatenation(input_shape_vector, 0)
assert "All inputs to concatenation must be the same size along all dimensions except the concatenation dimension" in str(
err.value)
def test_createdescriptorforconcatenation_ctor():
input_shape_vector = [ann.TensorShape((2, 1)), ann.TensorShape((3, 1)), ann.TensorShape((4, 1))]
desc = ann.CreateDescriptorForConcatenation(input_shape_vector, 0)
assert 3 == desc.GetNumViews()
assert 0 == desc.GetConcatAxis()
assert 2 == desc.GetNumDimensions()
c = desc.GetViewOrigin(1)
d = desc.GetViewOrigin(0)
def test_const_tensor_from_tensor_has_memory_area_access_after_deletion_of_original_tensor(
):
tensor_info = ann.TensorInfo(ann.TensorShape((2, 3)), ann.DataType_Float32)
tensor = ann.Tensor(tensor_info)
tensor.get_memory_area()[0] = 100
copied_mem = tensor.get_memory_area().copy()
assert 100 == copied_mem[0], "Memory was copied correctly"
copied_tensor = ann.ConstTensor(tensor)
tensor.get_memory_area()[0] = 200
assert 200 == tensor.get_memory_area(
)[0], "Tensor and copied Tensor point to the same memory"
assert 200 == copied_tensor.get_memory_area(
)[0], "Tensor and copied Tensor point to the same memory"
assert 100 == copied_mem[0], "Copied test memory not affected"
copied_mem[0] = 200 # modify test memory to equal copied Tensor
del tensor
np.testing.assert_array_equal(copied_tensor.get_memory_area(), copied_mem), "After initial tensor was deleted, " \
"copied Tensor still has " \
"its memory as expected"
def test_const_tensor_multi_dimensional_input(dt, data):
tensor = ann.ConstTensor(ann.TensorInfo(ann.TensorShape((2, 2, 3, 3)), dt),
data)
assert data.size == tensor.GetNumElements()
assert data.nbytes == tensor.GetNumBytes()
assert dt == tensor.GetDataType()
assert tensor.get_memory_area().data
def test_tensor_shape__set_item_out_of_bounds():
tensor_shape = ann.TensorShape((1, 2, 3))
with pytest.raises(ValueError) as err:
for i in range(4):
tensor_shape[i] = 1
assert "Invalid dimension index: 3 (number of dimensions is 3)" in str(
err.value)
def test_caffe_parser_end_to_end(shared_data_folder):
parser = ann.ICaffeParser = ann.ICaffeParser()
# Load the network specifying the inputs and outputs
input_name = "Placeholder"
tensor_shape = {input_name: ann.TensorShape((1, 1, 28, 28))}
requested_outputs = ["output"]
network = parser.CreateNetworkFromBinaryFile(
os.path.join(shared_data_folder, 'mock_model.caffemodel'),
tensor_shape, requested_outputs)
# Specify preferred backend
preferred_backends = [ann.BackendId('CpuAcc'), ann.BackendId('CpuRef')]
input_binding_info = parser.GetNetworkInputBindingInfo(input_name)
options = ann.CreationOptions()
runtime = ann.IRuntime(options)
opt_network, messages = ann.Optimize(network, preferred_backends,
runtime.GetDeviceSpec(),
ann.OptimizerOptions())
assert 0 == len(messages)
net_id, messages = runtime.LoadNetwork(opt_network)
assert "" == messages
# Load test image data stored in input_caffe.npy
input_tensor_data = np.load(
os.path.join(shared_data_folder,
'caffe_parser/input_caffe.npy')).astype(np.float32)
input_tensors = ann.make_input_tensors([input_binding_info],
[input_tensor_data])
# Load output binding info and
outputs_binding_info = []
for output_name in requested_outputs:
outputs_binding_info.append(
parser.GetNetworkOutputBindingInfo(output_name))
output_tensors = ann.make_output_tensors(outputs_binding_info)
runtime.EnqueueWorkload(net_id, input_tensors, output_tensors)
output_vectors = ann.workload_tensors_to_ndarray(output_tensors)
# Load golden output file for result comparison.
expected_output = np.load(
os.path.join(shared_data_folder,
'caffe_parser/golden_output_caffe.npy'))
# Check that output matches golden output to 4 decimal places (there are slight rounding differences after this)
np.testing.assert_almost_equal(output_vectors[0], expected_output, 4)
def test_create_const_tensor_from_tensor():
tensor_info = ann.TensorInfo(ann.TensorShape((2, 3)), ann.DataType_Float32)
tensor = ann.Tensor(tensor_info)
copied_tensor = ann.ConstTensor(tensor)
assert copied_tensor != tensor, "Different objects"
assert copied_tensor.GetInfo() != tensor.GetInfo(), "Different objects"
assert copied_tensor.get_memory_area(
).ctypes.data == tensor.get_memory_area().ctypes.data, "Same memory area"
assert copied_tensor.GetNumElements() == tensor.GetNumElements()
assert copied_tensor.GetNumBytes() == tensor.GetNumBytes()
assert copied_tensor.GetDataType() == tensor.GetDataType()
def test_tensor_info_ctor_shape():
tensor_shape = ann.TensorShape((1, 1, 2))
tensor_info = ann.TensorInfo(tensor_shape, ann.DataType_QAsymmU8, 0.5, 1)
assert 2 == tensor_info.GetNumElements()
assert 3 == tensor_info.GetNumDimensions()
assert ann.DataType_QAsymmU8 == tensor_info.GetDataType()
assert 0.5 == tensor_info.GetQuantizationScale()
assert 1 == tensor_info.GetQuantizationOffset()
shape = tensor_info.GetShape()
assert 2 == shape.GetNumElements()
assert 3 == shape.GetNumDimensions()
def test_output_slot(self, network):
# Create input, addition & output layer
input1 = network.AddInputLayer(0, "input1")
input2 = network.AddInputLayer(1, "input2")
add = network.AddAdditionLayer("addition")
output = network.AddOutputLayer(0, "output")
# Connect the input/output slots for each layer
input1.GetOutputSlot(0).Connect(add.GetInputSlot(0))
input2.GetOutputSlot(0).Connect(add.GetInputSlot(1))
add.GetOutputSlot(0).Connect(output.GetInputSlot(0))
# Check IInputSlot GetConnection()
add_get_input_connection = add.GetInputSlot(0).GetConnection()
output_get_input_connection = output.GetInputSlot(0).GetConnection()
# Check IOutputSlot GetConnection()
add_get_output_connect = add.GetOutputSlot(0).GetConnection(0)
assert isinstance(add_get_output_connect.GetConnection(), ann.IOutputSlot)
# Test IOutputSlot GetNumConnections() & CalculateIndexOnOwner()
assert add_get_input_connection.GetNumConnections() == 1
assert len(add_get_input_connection) == 1
assert add_get_input_connection[0]
assert add_get_input_connection.CalculateIndexOnOwner() == 0
# Check GetOwningLayerGuid(). Check that it is different for add and output layer
assert add_get_input_connection.GetOwningLayerGuid() != output_get_input_connection.GetOwningLayerGuid()
# Set TensorInfo
test_tensor_info = ann.TensorInfo(ann.TensorShape((2, 3)), ann.DataType_Float32)
# Check IsTensorInfoSet()
assert not add_get_input_connection.IsTensorInfoSet()
add_get_input_connection.SetTensorInfo(test_tensor_info)
assert add_get_input_connection.IsTensorInfoSet()
# Check GetTensorInfo()
output_tensor_info = add_get_input_connection.GetTensorInfo()
assert 2 == output_tensor_info.GetNumDimensions()
assert 6 == output_tensor_info.GetNumElements()
# Check Disconnect()
assert output_get_input_connection.GetNumConnections() == 1 # 1 connection to Outputslot0 from input1
add.GetOutputSlot(0).Disconnect(output.GetInputSlot(0)) # disconnect add.OutputSlot0 from Output.InputSlot0
assert output_get_input_connection.GetNumConnections() == 0
def test_filenotfound_exception(shared_data_folder):
parser = ann.ICaffeParser()
# path to model
path_to_model = os.path.join(shared_data_folder,
'some_unknown_network.caffemodel')
# generic tensor shape [1, 1, 1, 1]
tensor_shape = {'data': ann.TensorShape((1, 1, 1, 1))}
# requested_outputs
requested_outputs = [""]
with pytest.raises(RuntimeError) as err:
parser.CreateNetworkFromBinaryFile(path_to_model, tensor_shape,
requested_outputs)
# Only check for part of the exception since the exception returns
# absolute path which will change on different machines.
assert 'Failed to open graph file' in str(err.value)
def parser(shared_data_folder):
"""
Parse and setup the test network to be used for the tests below
"""
# Create caffe parser
parser = ann.ICaffeParser()
# Specify path to model
path_to_model = os.path.join(shared_data_folder, 'mock_model.caffemodel')
# Specify the tensor shape relative to the input [1, 1, 28, 28]
tensor_shape = {'Placeholder': ann.TensorShape((1, 1, 28, 28))}
# Specify the requested_outputs
requested_outputs = ["output"]
# Parse caffe binary & create network
parser.CreateNetworkFromBinaryFile(path_to_model, tensor_shape,
requested_outputs)
yield parser
def test_tensor_shape_one():
tensor_shape = ann.TensorShape((10, ))
assert 1 == tensor_shape.GetNumDimensions()
assert 10 == tensor_shape.GetNumElements()
def test_tensor_shape_tuple_mess():
tensor_shape = ann.TensorShape((1, "2", 3.0))
assert 3 == tensor_shape.GetNumDimensions()
assert 6 == tensor_shape.GetNumElements()
def _get_tensor_info(dt):
tensor_info = ann.TensorInfo(ann.TensorShape((2, 3)), dt)
return tensor_info
def test_tensor_shape_list():
with pytest.raises(TypeError) as err:
ann.TensorShape([1, 2, 3])
assert "Argument is not a tuple" in str(err.value)
def test_add_constant_layer_to_fully_connected():
inputWidth = 1
inputHeight = 1
inputChannels = 5
inputNum = 2
outputChannels = 3
outputNum = 2
inputShape = (inputNum, inputChannels, inputHeight, inputWidth)
outputShape = (outputNum, outputChannels)
weightsShape = (inputChannels, outputChannels)
biasShape = (outputChannels, )
input = np.array([[1.0, 2.0, 3.0, 4.0, 5.0], [5.0, 4.0, 3.0, 2.0, 1.0]],
dtype=np.float32)
weights = np.array(
[[.5, 2., .5], [.5, 2., 1.], [.5, 2., 2.], [.5, 2., 3.], [.5, 2., 4.]],
dtype=np.float32)
biasValues = np.array([10, 20, 30], dtype=np.float32)
expectedOutput = np.array([[
0.5 + 1.0 + 1.5 + 2.0 + 2.5 + biasValues[0], 2.0 + 4.0 + 6.0 + 8.0 +
10. + biasValues[1], 0.5 + 2.0 + 6.0 + 12. + 20. + biasValues[2]
],
[
2.5 + 2.0 + 1.5 + 1.0 + 0.5 + biasValues[0],
10.0 + 8.0 + 6.0 + 4.0 + 2. + biasValues[1],
2.5 + 4.0 + 6.0 + 6. + 4. + biasValues[2]
]],
dtype=np.float32)
network = ann.INetwork()
input_info = ann.TensorInfo(ann.TensorShape(inputShape),
ann.DataType_Float32, 0, 0, True)
input_tensor = ann.ConstTensor(input_info, input)
input_layer = network.AddInputLayer(0, "input")
w_info = ann.TensorInfo(ann.TensorShape(weightsShape),
ann.DataType_Float32, 0, 0, True)
w_tensor = ann.ConstTensor(w_info, weights)
w_layer = network.AddConstantLayer(w_tensor, "weights")
b_info = ann.TensorInfo(ann.TensorShape(biasShape), ann.DataType_Float32,
0, 0, True)
b_tensor = ann.ConstTensor(b_info, biasValues)
b_layer = network.AddConstantLayer(b_tensor, "bias")
fc_descriptor = ann.FullyConnectedDescriptor()
fc_descriptor.m_BiasEnabled = True
fc_descriptor.m_ConstantWeights = True
fully_connected = network.AddFullyConnectedLayer(fc_descriptor, "fc")
output_info = ann.TensorInfo(ann.TensorShape(outputShape),
ann.DataType_Float32)
output_tensor = ann.Tensor(output_info, np.zeros([1, 1], dtype=np.float32))
output = network.AddOutputLayer(0, "output")
input_layer.GetOutputSlot(0).Connect(fully_connected.GetInputSlot(0))
w_layer.GetOutputSlot(0).Connect(fully_connected.GetInputSlot(1))
b_layer.GetOutputSlot(0).Connect(fully_connected.GetInputSlot(2))
fully_connected.GetOutputSlot(0).Connect(output.GetInputSlot(0))
input_layer.GetOutputSlot(0).SetTensorInfo(input_info)
w_layer.GetOutputSlot(0).SetTensorInfo(w_info)
b_layer.GetOutputSlot(0).SetTensorInfo(b_info)
fully_connected.GetOutputSlot(0).SetTensorInfo(output_info)
preferred_backends = [ann.BackendId('CpuRef')]
options = ann.CreationOptions()
runtime = ann.IRuntime(options)
opt_network, messages = ann.Optimize(network, preferred_backends,
runtime.GetDeviceSpec(),
ann.OptimizerOptions())
net_id, messages = runtime.LoadNetwork(opt_network)
input_tensors = [(0, input_tensor)]
output_tensors = [(0, output_tensor)]
runtime.EnqueueWorkload(net_id, input_tensors, output_tensors)
output_vectors = ann.workload_tensors_to_ndarray(output_tensors)
assert (output_vectors == expectedOutput).all()
def test_tensor_shape_tuple_mess_fail():
with pytest.raises(TypeError) as err:
ann.TensorShape((1, "two", 3.0))
assert "All elements must be numbers" in str(err.value)
def test_tensor_shape_varags():
with pytest.raises(TypeError) as err:
ann.TensorShape(1, 2, 3)
assert "__init__() takes 2 positional arguments but 4 were given" in str(
err.value)
def test_tensor_shape_tuple():
tensor_shape = ann.TensorShape((1, 2, 3))
assert 3 == tensor_shape.GetNumDimensions()
assert 6 == tensor_shape.GetNumElements()
def test_tensor_shape_empty():
with pytest.raises(RuntimeError) as err:
ann.TensorShape(())
assert "Tensor numDimensions must be greater than 0" in str(err.value)
def test_tensor_info__str__():
tensor_info = ann.TensorInfo(ann.TensorShape((2, 3)),
ann.DataType_QAsymmU8, 0.5, 1)
assert tensor_info.__str__() == "TensorInfo{DataType: 2, IsQuantized: 1, QuantizationScale: 0.500000, " \
"QuantizationOffset: 1, NumDimensions: 2, NumElements: 6}"
def test_tensor_shape___str__():
tensor_shape = ann.TensorShape((1, 2, 3))
assert str(
tensor_shape
) == "TensorShape{Shape(1, 2, 3), NumDimensions: 3, NumElements: 6}"
