def test_attr_sparse_tensor_repeated_protos(self): # type: () -> None
dense_shape = [3, 3]
sparse_values = [
1.764052391052246, 0.40015721321105957, 0.978738009929657
]
values_tensor = helper.make_tensor(name='sparse_values',
data_type=TensorProto.FLOAT,
dims=[len(sparse_values)],
vals=np.array(sparse_values).astype(
np.float32),
raw=False)
linear_indicies = [2, 3, 5]
indicies_tensor = helper.make_tensor(
name='indicies',
data_type=TensorProto.INT64,
dims=[len(linear_indicies)],
vals=np.array(linear_indicies).astype(np.int64),
raw=False)
sparse_tensor = helper.make_sparse_tensor(values_tensor,
indicies_tensor, dense_shape)
repeated_sparse = [sparse_tensor, sparse_tensor]
attr = helper.make_attribute("sparse_attrs", repeated_sparse)
self.assertEqual(attr.name, "sparse_attrs")
checker.check_attribute(attr)
for s in helper.get_attribute_value(attr):
checker.check_sparse_tensor(s)
def create_model(constant_node_name, output_file_name):
dense_shape = [3,3]
sparse_values = [1.764052391052246, 0.40015721321105957, 0.978738009929657]
values_tensor = helper.make_tensor(name='Constant', data_type=TensorProto.FLOAT,
dims=[len(sparse_values)],
vals=np.array(sparse_values).astype(np.float32), raw=False)
linear_indicies = [2, 3, 5]
indicies_tensor = helper.make_tensor(name='indicies', data_type=TensorProto.INT64,
dims=[len(linear_indicies)],
vals=np.array(linear_indicies).astype(np.int64), raw=False)
sparse_tensor = helper.make_sparse_tensor(values_tensor, indicies_tensor, dense_shape)
# Nodes
#sparse_attribute = helper.make_attribute('value', sparse_tensor)
constant_node = helper.make_node(constant_node_name, inputs=[], outputs=['values'],
name='Constant', domain='', value=sparse_tensor)
# Outputs, a square matrix
Values_info = make_sparse_tensor_value_info('values', TensorProto.FLOAT, dense_shape)
graph_def = helper.make_graph(nodes=[constant_node],
name='ConstantNodeOutput',
inputs=[],
outputs=[Values_info])
model_def = helper.make_model(graph_def, producer_name='dmitrism',
opset_imports=[make_opsetid('', 12)])
onnx.save(model_def, output_file_name)
def test_make_sparse_tensor(self): # type: () -> None
values = [1.1, 2.2, 3.3, 4.4, 5.5]
values_tensor = helper.make_tensor(name='test',
data_type=TensorProto.FLOAT,
dims=(5, ),
vals=values)
indices = [1, 3, 5, 7, 9]
indices_tensor = helper.make_tensor(name='test_indices',
data_type=TensorProto.INT64,
dims=(5, ),
vals=indices)
dense_shape = [10]
sparse = helper.make_sparse_tensor(values_tensor, indices_tensor,
dense_shape)
self.assertEqual(sparse.values, values_tensor)
self.assertEqual(sparse.indices, indices_tensor)
self.assertEqual(sparse.dims, dense_shape)
def _make_sparse_tensor(name: str) -> SparseTensorProto:
dense_shape = [3, 3]
linear_indices = [2, 3, 5]
sparse_values = [1.7, 0.4, 0.9]
values_tensor = helper.make_tensor(name=name + "_values",
data_type=TensorProto.FLOAT,
dims=[len(sparse_values)],
vals=np.array(sparse_values).astype(
np.float32),
raw=False)
indices_tensor = helper.make_tensor(name=name + "_idx",
data_type=TensorProto.INT64,
dims=[len(linear_indices)],
vals=np.array(linear_indices).astype(
np.int64),
raw=False)
return helper.make_sparse_tensor(values_tensor, indices_tensor,
dense_shape)
def test_constant(self):
shape = [16, 16]
values = np.random.randn(*shape).flatten().astype(float)
const2_onnx = helper.make_tensor("const2", TensorProto.DOUBLE, shape,
values)
node_def = helper.make_node("Constant", [], ["Y"], value=const2_onnx)
output = run_node(node_def, [])
np.testing.assert_equal(output["Y"].shape, shape)
np.testing.assert_almost_equal(output["Y"].flatten(), values)
# test sparse tensor
if not legacy_opset_pre_ver(11):
expected = np.array([[1, 0, 0, 0], [0, 0, 2, 0], [0, 0, 0, 0]])
x = np.array([[0, 0], [1, 2]]).flatten().astype(np.int64)
values = helper.make_tensor("values", TensorProto.INT32, [2], [1, 2])
indices = helper.make_tensor("indices", TensorProto.INT64, [2, 2], x)
a = helper.make_sparse_tensor(values, indices,[3, 4])
node_def = helper.make_node("Constant", [], ["Y"], sparse_value=a)
output = run_node(node_def, [])
b = tf.sparse_to_dense(output["Y"].indices, output["Y"].dense_shape, output["Y"].values)
result = b.eval(session=tf.Session())
np.testing.assert_equal(result, expected)
