def test_multiple_registrations(self):
assert OpaqueFuncRegistry.Size() == 0
@register_opaque_func('py_func1', [TypeCode.Str, TypeCode.XGraph])
def py_func(str_name, xgraph):
assert xgraph.get_name() == "name1"
xgraph.set_name(str_name)
@register_opaque_func('py_func2', [TypeCode.Str, TypeCode.XGraph])
def py_func2(str_name, xgraph):
xgraph.add(XLayer(name=str_name, type=[str_name]))
assert OpaqueFuncRegistry.Size() == 2
assert set(OpaqueFuncRegistry.GetRegisteredFuncs()) == \
set(['py_func1', 'py_func2'])
xg = XGraph("name1")
of1 = OpaqueFuncRegistry.Get("py_func1")
of1("name2", xg)
assert xg.get_name() == "name2"
assert len(xg) == 0
of2 = OpaqueFuncRegistry.Get("py_func2")
of2("x1", xg)
assert xg.get_name() == "name2"
assert len(xg) == 1
assert xg.get('x1').name == 'x1'
assert xg.get('x1').type == ['x1']
def test_xgraph_layer_add(self):
def py_func(xg):
assert xg.get_name() == "test"
X = XLayer(name='x1', type=['X1'])
xg.add(X)
xgraph = XGraph("test")
assert len(xgraph) == 0
of = OpaqueFunc(py_func, [TypeCode.XGraph])
of(xgraph)
assert xgraph.get_name() == "test"
assert len(xgraph) == 1
assert xgraph.get('x1').type == ['X1']
def test_xgraph_add_get(self):
xgraph = XGraph()
xgraph.add(XLayer(
name='in1',
type=['Input'],
bottoms=[],
tops=[],
targets=[]
))
assert len(xgraph) == 1
assert len(xgraph.get_layer_names()) == 1
assert len(xgraph.get_output_names()) == 1
assert len(xgraph.get_input_names()) == 1
assert isinstance(xgraph.get('in1'), XLayer)
assert xgraph.get('in1').bottoms == []
assert xgraph.get('in1').tops == []
X_conv = XLayer(
name='conv1',
type=['Convolution'],
bottoms=['in1'],
tops=[],
data=ConvData(
weights=np.array([[[[1, 2], [3, 4]]]], dtype=np.float32),
biases=np.array([0., 1.], dtype=np.float32)
),
targets=[]
)
xgraph.add(X_conv)
assert len(xgraph) == 2
assert xgraph.get_layer_names() == ['in1', 'conv1']
assert xgraph.get_output_names() == ['conv1']
assert xgraph.get_input_names() == ['in1']
assert xgraph.get('in1').tops == ['conv1']
assert isinstance(xgraph.get('conv1'), XLayer)
assert xgraph.get('conv1').bottoms == ['in1']
assert xgraph.get('conv1').tops == []
assert xgraph.get('conv1').type == ['Convolution']
np.testing.assert_array_equal(
xgraph.get('conv1').data.weights,
np.array([[[[1, 2], [3, 4]]]], dtype=np.float32)
)
np.testing.assert_array_equal(
xgraph.get('conv1').data.biases,
np.array([0., 1.], dtype=np.float32)
)
xgraph.get('conv1').data = ConvData(
weights=xgraph.get('conv1').data.weights * 2,
biases=xgraph.get('conv1').data.biases
)
np.testing.assert_array_equal(
xgraph.get('conv1').data.weights,
np.array([[[[2, 4], [6, 8]]]], dtype=np.float32)
)
xgraph.remove(X_conv.name)
assert len(xgraph) == 1
assert 'in1' in xgraph
assert len(xgraph.get_layer_names()) == 1
assert len(xgraph.get_output_names()) == 1
assert len(xgraph.get_input_names()) == 1
def test_copy(self):
xgraph = XGraph()
xgraph.add(XLayer(
name='in1',
type=['Input'],
bottoms=[],
tops=[],
targets=[]
))
xgraph.add(XLayer(
name='in2',
type=['Input'],
bottoms=[],
tops=[],
targets=[]
))
xgraph.add(XLayer(
name='conv1',
type=['Convolution'],
bottoms=['in1'],
tops=[],
data=ConvData(
weights=np.array([[[[1, 2], [3, 4]]]], dtype=np.float32),
biases=np.array([0., 1.], dtype=np.float32)
),
targets=[]
))
xgraph.add(XLayer(
name='add1',
type=['Eltwise'],
bottoms=['conv1', 'in2'],
tops=[],
targets=[]
))
xgraph.insert(XLayer(
name='conv2',
type=['Convolution'],
bottoms=['in2'],
tops=['add1'],
data=ConvData(
weights=np.array([[[[1, 2], [3, 4]]]], dtype=np.float32),
biases=np.array([0., 1.], dtype=np.float32)
),
targets=[]
))
xgraph.add(XLayer(
name='pool1',
type=['Pooling'],
bottoms=['add1'],
tops=[],
targets=[]
))
assert len(xgraph) == 6
assert xgraph.get_layer_names() == \
['in1', 'conv1', 'in2', 'conv2', 'add1', 'pool1']
xg_copy = xgraph.copy()
assert len(xg_copy) == 6
assert xg_copy.get_layer_names() == \
['in1', 'conv1', 'in2', 'conv2', 'add1', 'pool1']
xgc_layers = xg_copy.get_layers()
assert xgc_layers[1].type == ['Convolution']
assert xg_copy.get('conv1').type == ['Convolution']
xgc_layers[1].type = ['Convolution2']
assert xg_copy.get('conv1').type == ['Convolution2']
xgc_layers[1].type = ['Convolution']
assert xgc_layers[1].type == ['Convolution']
assert xg_copy.get('conv1').type == ['Convolution']
np.testing.assert_array_equal(
xgc_layers[1].data.weights,
np.array([[[[1, 2], [3, 4]]]], dtype=np.float32)
)
np.testing.assert_array_equal(
xgc_layers[1].data.biases,
np.array([0., 1.], dtype=np.float32)
)
xgraph.get('conv1').data = ConvData(
weights=xgc_layers[1].data.weights * 2,
biases=xgc_layers[1].data.biases
)
np.testing.assert_array_equal(
xgraph.get('conv1').data.weights,
np.array([[[[2, 4], [6, 8]]]], dtype=np.float32)
)
np.testing.assert_array_equal(
xgc_layers[1].data.weights,
np.array([[[[1, 2], [3, 4]]]], dtype=np.float32)
)
np.testing.assert_array_equal(
xgc_layers[1].data.biases,
np.array([0., 1.], dtype=np.float32)
)
def _test_add_get(in_name: str, conv_name: str):
expected_in_name = px.stringify(in_name)
expected_conv_name = px.stringify(conv_name)
in1 = px.ops.input(op_name=expected_in_name, shape=[1, 2, 4, 4])
W = px.ops.constant(
"W", np.array([[[[1, 2], [3, 4]]]], dtype=np.float32))
X_conv = px.ops.conv2d(op_name=conv_name,
input_layer=in1,
weights_layer=W,
kernel_size=[2, 2])
xgraph = XGraph()
xgraph.add(in1)
assert len(xgraph) == 1
assert len(xgraph.get_layer_names()) == 1
assert len(xgraph.get_output_names()) == 1
assert len(xgraph.get_input_names()) == 1
assert isinstance(xgraph.get(in_name), XLayer)
assert xgraph.get(in_name).bottoms == []
assert xgraph.get(in_name).tops == []
xgraph.add(X_conv)
assert len(xgraph) == 2
assert xgraph.get_layer_names() == [
expected_in_name, expected_conv_name
]
assert xgraph.get_output_names() == [expected_conv_name]
assert xgraph.get_input_names() == [expected_in_name]
assert xgraph.get(in_name).tops == [expected_conv_name]
assert isinstance(xgraph.get(conv_name), XLayer)
assert xgraph.get(conv_name).bottoms == [expected_in_name]
assert xgraph.get(conv_name).tops == []
assert xgraph.get(conv_name).type == ["Convolution"]
np.testing.assert_array_equal(
xgraph.get(conv_name).data.weights,
np.array([[[[1, 2], [3, 4]]]], dtype=np.float32),
)
np.testing.assert_array_equal(
xgraph.get(conv_name).data.biases,
np.array([0.0], dtype=np.float32),
)
xgraph.get(conv_name).data = ConvData(
weights=xgraph.get(conv_name).data.weights * 2,
biases=xgraph.get(conv_name).data.biases,
)
np.testing.assert_array_equal(
xgraph.get(conv_name).data.weights,
np.array([[[[2, 4], [6, 8]]]], dtype=np.float32),
)
xgraph.remove(X_conv.name)
assert len(xgraph) == 1
assert in_name in xgraph
assert len(xgraph.get_layer_names()) == 1
assert len(xgraph.get_output_names()) == 1
assert len(xgraph.get_input_names()) == 1
def _test_copy(
in1_name: str,
in2_name: str,
conv1_name: str,
add_name: str,
conv2_name: str,
pool_name: str,
):
expected_in1_name = px.stringify(in1_name)
expected_in2_name = px.stringify(in2_name)
expected_conv1_name = px.stringify(conv1_name)
expected_conv2_name = px.stringify(conv2_name)
expected_pool_name = px.stringify(pool_name)
expected_add_name = px.stringify(add_name)
in1 = px.ops.input(op_name=in1_name, shape=[1, 2, 4, 4])
in2 = px.ops.input(op_name=in2_name, shape=[1, 2, 4, 4])
W = px.ops.constant(
"W", np.array([[[[1, 2], [3, 4]]]], dtype=np.float32))
X_conv = px.ops.conv2d(op_name=conv1_name,
input_layer=in1,
weights_layer=W,
kernel_size=[2, 2])
X_add = px.ops.eltwise(op_name=add_name,
lhs_layer=X_conv,
rhs_layer=in2)
X_conv2 = px.ops.conv2d(op_name=conv2_name,
input_layer=in2,
weights_layer=W,
kernel_size=[2, 2])
X_pool = px.ops.pool2d(op_name=pool_name,
input_layer=X_add,
pool_type="Avg",
pool_size=[2, 2])
xgraph = XGraph()
xgraph.add(in1)
xgraph.add(in2)
xgraph.add(X_conv)
xgraph.add(X_add)
xgraph.insert(
XLayer(
name=conv2_name,
type=["Convolution"],
bottoms=[in2_name],
tops=[add_name],
data=ConvData(
weights=np.array([[[[1, 2], [3, 4]]]],
dtype=np.float32),
biases=np.array([0.0, 1.0], dtype=np.float32),
),
targets=[],
))
xgraph.add(X_pool)
assert len(xgraph) == 6
assert xgraph.get_layer_names() == [
expected_in1_name,
expected_conv1_name,
expected_in2_name,
expected_conv2_name,
expected_add_name,
expected_pool_name,
]
xg_copy = xgraph.copy()
assert len(xg_copy) == 6
assert xg_copy.get_layer_names() == [
expected_in1_name,
expected_conv1_name,
expected_in2_name,
expected_conv2_name,
expected_add_name,
expected_pool_name,
]
xgc_layers = xg_copy.get_layers()
assert xgc_layers[1].type == ["Convolution"]
assert xg_copy.get(conv1_name).type == ["Convolution"]
xgc_layers[1].type = ["Convolution2"]
assert xg_copy.get(conv1_name).type == ["Convolution2"]
xgc_layers[1].type = ["Convolution"]
assert xgc_layers[1].type == ["Convolution"]
assert xg_copy.get(conv1_name).type == ["Convolution"]
np.testing.assert_array_equal(
xgc_layers[1].data.weights,
np.array([[[[1, 2], [3, 4]]]], dtype=np.float32),
)
np.testing.assert_array_equal(xgc_layers[1].data.biases,
np.array([0.0], dtype=np.float32))
xgraph.get(conv1_name).data = ConvData(
weights=xgc_layers[1].data.weights * 2,
biases=xgc_layers[1].data.biases)
np.testing.assert_array_equal(
xgraph.get(conv1_name).data.weights,
np.array([[[[2, 4], [6, 8]]]], dtype=np.float32),
)
np.testing.assert_array_equal(
xgc_layers[1].data.weights,
np.array([[[[1, 2], [3, 4]]]], dtype=np.float32),
)
np.testing.assert_array_equal(xgc_layers[1].data.biases,
np.array([0.0], dtype=np.float32))
