def _test_relu_graph(self, X, batch_size, trt_max_batch_size):
node_def = make_node("Relu", ["X"], ["Y"])
Y_c2 = c2.run_node(node_def, {"X": X})
graph_def = make_graph(
[node_def],
name="test",
inputs=[
make_tensor_value_info("X", onnx.TensorProto.FLOAT,
[batch_size, 1, 3, 2])
],
outputs=[
make_tensor_value_info("Y", onnx.TensorProto.FLOAT,
[batch_size, 1, 3, 2])
])
model_def = make_model(graph_def, producer_name='relu-test')
op_outputs = [x.name for x in model_def.graph.output]
op = convert_onnx_model_to_trt_op(model_def,
max_batch_size=trt_max_batch_size)
device_option = core.DeviceOption(caffe2_pb2.CUDA, 0)
op.device_option.CopyFrom(device_option)
Y_trt = None
ws = Workspace()
with core.DeviceScope(device_option):
ws.FeedBlob("X", X)
ws.RunOperatorsOnce([op])
output_values = [ws.FetchBlob(name) for name in op_outputs]
Y_trt = namedtupledict('Outputs', op_outputs)(*output_values)
np.testing.assert_almost_equal(Y_c2, Y_trt)
def test_gemm(self):
# simple
A = np.random.randn(3, 2).astype(np.float32)
B = np.random.randn(2, 4).astype(np.float32)
C = np.random.randn(3, 4).astype(np.float32)
node_def = make_node('Gemm', ['A', 'B', 'C'], ["Y"])
output = c2.run_node(node_def, [A, B, C])
np.testing.assert_almost_equal(output["Y"], np.dot(A, B) + C)
# transA
A = np.transpose(A)
node_def = make_node('Gemm', ['A', 'B', 'C'], ["Y"], transA=True)
output = c2.run_node(node_def, [A, B, C])
np.testing.assert_almost_equal(output["Y"],
np.dot(np.transpose(A), B) + C)
# revert A
A = np.transpose(A)
# transB
B = np.transpose(B)
node_def = make_node('Gemm', ['A', 'B', 'C'], ["Y"], transB=True)
output = c2.run_node(node_def, [A, B, C])
np.testing.assert_almost_equal(output["Y"],
np.dot(A, np.transpose(B)) + C)
# revert A
B = np.transpose(B)
# scale
alpha = np.random.random()
beta = np.random.random()
node_def = make_node('Gemm', ['A', 'B', 'C'], ["Y"],
alpha=alpha,
beta=beta)
output = c2.run_node(node_def, [A, B, C])
np.testing.assert_almost_equal(output["Y"],
alpha * np.dot(A, B) + beta * C)
# broadcast
C = np.random.randn(4).astype(np.float32)
node_def = make_node('Gemm', ['A', 'B', 'C'], ["Y"],
alpha=alpha,
beta=beta,
broadcast=1)
output = c2.run_node(node_def, [A, B, C])
np.testing.assert_almost_equal(output["Y"],
alpha * np.dot(A, B) + beta * C)
def test_relu_graph(self):
X = np.random.randn(3, 2).astype(np.float32)
Y_ref = np.clip(X, 0, np.inf)
node_def = make_node(
"Relu", ["X"], ["Y"])
output = c2.run_node(
node_def, {"X": X})
np.testing.assert_almost_equal(output.Y, Y_ref)
graph_def = make_graph(
[node_def],
name="test",
inputs=[make_tensor_value_info("X", onnx.TensorProto.FLOAT, [3, 2])],
outputs=[make_tensor_value_info("Y", onnx.TensorProto.FLOAT, [3, 2])])
c2_rep = c2.prepare(make_model(graph_def, producer_name='caffe2-ref-test'))
output = c2_rep.run(X)
np.testing.assert_almost_equal(output.Y, Y_ref)
def test_relu_graph(self):
X = np.random.randn(3, 2).astype(np.float32)
Y_ref = np.clip(X, 0, np.inf)
node_def = make_node(
"Relu", ["X"], ["Y"])
output = c2.run_node(
node_def, {"X": X})
np.testing.assert_almost_equal(output.Y, Y_ref)
graph_def = make_graph(
[node_def],
name="test",
inputs=[make_tensor_value_info("X", onnx.TensorProto.FLOAT, [3, 2])],
outputs=[make_tensor_value_info("Y", onnx.TensorProto.FLOAT, [3, 2])])
c2_rep = c2.prepare(make_model(graph_def, producer_name='caffe2-ref-test'))
output = c2_rep.run(X)
np.testing.assert_almost_equal(output.Y, Y_ref)
def _test_relu_graph(self, X, batch_size, trt_max_batch_size):
node_def = make_node("Relu", ["X"], ["Y"])
Y_c2 = c2.run_node(node_def, {"X": X})
graph_def = make_graph(
[node_def],
name="test",
inputs=[make_tensor_value_info("X", onnx.TensorProto.FLOAT, [batch_size, 1, 3, 2])],
outputs=[make_tensor_value_info("Y", onnx.TensorProto.FLOAT, [batch_size, 1, 3, 2])])
model_def = make_model(graph_def, producer_name='relu-test')
op_outputs = [x.name for x in model_def.graph.output]
op = convert_onnx_model_to_trt_op(model_def, max_batch_size=trt_max_batch_size)
device_option = core.DeviceOption(caffe2_pb2.CUDA, 0)
op.device_option.CopyFrom(device_option)
Y_trt = None
ws = Workspace()
with core.DeviceScope(device_option):
ws.FeedBlob("X", X)
ws.RunOperatorsOnce([op])
output_values = [ws.FetchBlob(name) for name in op_outputs]
Y_trt = namedtupledict('Outputs', op_outputs)(*output_values)
np.testing.assert_almost_equal(Y_c2, Y_trt)
def test_gemm(self):
# simple
A = np.random.randn(3, 2).astype(np.float32)
B = np.random.randn(2, 4).astype(np.float32)
C = np.random.randn(3, 4).astype(np.float32)
node_def = make_node('Gemm', ['A', 'B', 'C'], ["Y"])
output = c2.run_node(node_def, [A, B, C])
np.testing.assert_almost_equal(output["Y"], np.dot(A, B) + C)
# transA
A = np.transpose(A)
node_def = make_node('Gemm', ['A', 'B', 'C'], ["Y"], transA=1)
output = c2.run_node(node_def, [A, B, C])
np.testing.assert_almost_equal(output["Y"],
np.dot(np.transpose(A), B) + C)
# revert A
A = np.transpose(A)
# transB
B = np.transpose(B)
node_def = make_node('Gemm', ['A', 'B', 'C'], ["Y"], transB=1)
output = c2.run_node(node_def, [A, B, C])
np.testing.assert_almost_equal(output["Y"],
np.dot(A, np.transpose(B)) + C)
# revert B
B = np.transpose(B)
# scale
alpha = np.random.random()
beta = np.random.random()
node_def = make_node('Gemm', ['A', 'B', 'C'], ["Y"],
alpha=alpha,
beta=beta)
output = c2.run_node(node_def, [A, B, C])
np.testing.assert_almost_equal(output["Y"],
alpha * np.dot(A, B) + beta * C)
# setup broadcastable C
C = np.random.randn(4).astype(np.float32)
# broadcast for opset7
node_def = make_node('Gemm', ['A', 'B', 'C'], ["Y"],
alpha=alpha,
beta=beta)
output = c2.run_node(node_def, [A, B, C], opset_version=7)
np.testing.assert_almost_equal(output["Y"],
alpha * np.dot(A, B) + beta * C)
# broadcast for opset3 and 6
node_def = make_node('Gemm', ['A', 'B', 'C'], ["Y"],
alpha=alpha,
beta=beta,
broadcast=1)
output = c2.run_node(node_def, [A, B, C], opset_version=6)
np.testing.assert_almost_equal(output["Y"],
alpha * np.dot(A, B) + beta * C)
# transB
B = np.transpose(B)
# transB and broadcast for opset7
node_def = make_node('Gemm', ['A', 'B', 'C'], ["Y"],
alpha=alpha,
beta=beta,
transB=1)
output = c2.run_node(node_def, [A, B, C], opset_version=7)
np.testing.assert_almost_equal(
output["Y"],
alpha * np.dot(A, np.transpose(B)) + beta * C)
# transB and broadcast for opset3 and 6
node_def = make_node('Gemm', ['A', 'B', 'C'], ["Y"],
alpha=alpha,
beta=beta,
broadcast=1,
transB=1)
output = c2.run_node(node_def, [A, B, C], opset_version=6)
np.testing.assert_almost_equal(
output["Y"],
alpha * np.dot(A, np.transpose(B)) + beta * C)
# revert B
B = np.transpose(B)
# set a scalar to C
C = np.random.randn(1).astype(np.float32)
# scalar broadcast for opset7
node_def = make_node('Gemm', ['A', 'B', 'C'], ["Y"],
alpha=alpha,
beta=beta)
output = c2.run_node(node_def, [A, B, C], opset_version=7)
np.testing.assert_almost_equal(output["Y"],
alpha * np.dot(A, B) + beta * C)
# scalar broadcast for opset3 and 6
node_def = make_node('Gemm', ['A', 'B', 'C'], ["Y"],
alpha=alpha,
beta=beta,
broadcast=1)
output = c2.run_node(node_def, [A, B, C], opset_version=6)
np.testing.assert_almost_equal(output["Y"],
alpha * np.dot(A, B) + beta * C)
def test_gemm(self):
# simple
A = np.random.randn(3, 2).astype(np.float32)
B = np.random.randn(2, 4).astype(np.float32)
C = np.random.randn(3, 4).astype(np.float32)
node_def = make_node(
'Gemm',
['A', 'B', 'C'],
["Y"])
output = c2.run_node(node_def, [A, B, C])
np.testing.assert_almost_equal(output["Y"], np.dot(A, B) + C)
# transA
A = np.transpose(A)
node_def = make_node(
'Gemm',
['A', 'B', 'C'],
["Y"],
transA=True)
output = c2.run_node(node_def, [A, B, C])
np.testing.assert_almost_equal(
output["Y"],
np.dot(np.transpose(A), B) + C)
# revert A
A = np.transpose(A)
# transB
B = np.transpose(B)
node_def = make_node(
'Gemm',
['A', 'B', 'C'],
["Y"],
transB=True)
output = c2.run_node(node_def, [A, B, C])
np.testing.assert_almost_equal(
output["Y"],
np.dot(A, np.transpose(B)) + C)
# revert A
B = np.transpose(B)
# scale
alpha = np.random.random()
beta = np.random.random()
node_def = make_node(
'Gemm',
['A', 'B', 'C'],
["Y"],
alpha=alpha,
beta=beta)
output = c2.run_node(node_def, [A, B, C])
np.testing.assert_almost_equal(
output["Y"],
alpha * np.dot(A, B) + beta * C)
# broadcast
C = np.random.randn(4).astype(np.float32)
node_def = make_node(
'Gemm',
['A', 'B', 'C'],
["Y"],
alpha=alpha,
beta=beta,
broadcast=1)
output = c2.run_node(node_def, [A, B, C])
np.testing.assert_almost_equal(
output["Y"],
alpha * np.dot(A, B) + beta * C)
