experiments/STT-tensorflow
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #42044 from tfeher:trt_fix_naming_style

Browse Source 
PiperOrigin-RevId: 328673510
Change-Id: Ief79c54bb624353d223447924bb6e1c7e1d9b7b2
This commit is contained in:
TensorFlower Gardener 2020-08-26 22:10:27 -07:00
commit ecc6730253
1 changed files with 84 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

160
tensorflow/compiler/tf2tensorrt/convert/convert_nodes_test.cc
View File

@ -1709,12 +1709,12 @@ class ParameterizedOpConverterTestBase
std::tuple<TrtTestMode, DataType, TrtPrecisionMode>> {
public:
ParameterizedOpConverterTestBase()
: trt_mode(std::get<0>(GetParam())),
tf_type(std::get<1>(GetParam())),
converter_precision(std::get<2>(GetParam())) {}
: trt_mode_(std::get<0>(GetParam())),
tf_type_(std::get<1>(GetParam())),
converter_precision_(std::get<2>(GetParam())) {}
void Reset() {
OpConverterTest::Reset(converter_precision, trt_mode);
OpConverterTest::Reset(converter_precision_, trt_mode_);
input_data_.clear();
}
@ -1750,7 +1750,7 @@ class ParameterizedOpConverterTestBase
if (!partial_input_shape_dims.empty()) {
partial_shape = partial_input_shape_dims;
} else {
if (trt_mode == TrtTestMode::kDynamicShape) {
if (trt_mode_ == TrtTestMode::kDynamicShape) {
// In dynamic shape mode we make all dims unknown.
partial_shape = std::vector<int32>(dims.size(), -1);
} else {
@ -1776,7 +1776,7 @@ class ParameterizedOpConverterTestBase
void AddTestTensor(const string& name, const std::vector<int32>& dims,
const std::vector<T>& values = {},
const std::vector<int32>& partial_input_shape_dims = {}) {
AddTestTensor<T>(name, dims, tf_type, values, partial_input_shape_dims);
AddTestTensor<T>(name, dims, tf_type_, values, partial_input_shape_dims);
}
// Builds and runs the converted network. Checks output tensor shape. Tests
@ -1796,7 +1796,7 @@ class ParameterizedOpConverterTestBase
TensorShapeUtils::MakeShape(expected_output_dims[i], &shape));
string out_name = (n_output == 1) ? name : StrCat(name, ":", i);
DataType out_tf_type =
out_tf_types.size() > i ? out_tf_types[i] : tf_type;
out_tf_types.size() > i ? out_tf_types[i] : tf_type_;
InputOutputData data{
out_name, ConstructTensor(shape.num_elements(), 0, out_tf_type)};
output_data.push_back(data);
@ -1840,9 +1840,9 @@ class ParameterizedOpConverterTestBase
}
protected:
const TrtTestMode trt_mode;
const DataType tf_type;
const TrtPrecisionMode converter_precision;
const TrtTestMode trt_mode_;
const DataType tf_type_;
const TrtPrecisionMode converter_precision_;
DataVec input_data_;
};
@ -2075,7 +2075,7 @@ TEST_P(OpConverterTest1, ConvertFusedBatchNorm) {
37.342354, 41.013527, 30.9738, 34.469433,
45.018955, 48.59309, 59.369415, 63.04059};
for (auto get_node_def : get_node_def_vec) {
NodeDef tmp_node_def = get_node_def(tf_type, "NCHW", true, 0);
NodeDef tmp_node_def = get_node_def(tf_type_, "NCHW", true, 0);
std::string op_name = tmp_node_def.op();
std::vector<TestParam> test_param{
{"NHWC", 0, false, 0,
@ -2097,7 +2097,7 @@ TEST_P(OpConverterTest1, ConvertFusedBatchNorm) {
errors::Unimplemented(StrCat("The input \"variance\" for ", op_name,
" must be a constant, at my_batchnorm"))},
{"NCHW", 0, false, 0.01}}; // The last one is the only test that runs.
if (trt_mode == TrtTestMode::kDynamicShape) {
if (trt_mode_ == TrtTestMode::kDynamicShape) {
test_param.push_back(
{"NCHW", 0, false, 0.01,
errors::InvalidArgument(
@ -2107,7 +2107,7 @@ TEST_P(OpConverterTest1, ConvertFusedBatchNorm) {
for (auto p : test_param) {
Reset();
NodeDef node_def =
get_node_def(tf_type, p.data_format, p.is_training, p.epsilon);
get_node_def(tf_type_, p.data_format, p.is_training, p.epsilon);
for (int i = 0; i < node_input.size(); i++) {
if (i == 0 || i == p.tensor_input_idx) {
// The first input (x) is always added as a tensor, and it hase shape
@ -2126,7 +2126,7 @@ TEST_P(OpConverterTest1, ConvertFusedBatchNorm) {
// the first arg is a tensor. TODO(tfeher) Check if one can relax this
// restriction.
Status expected_status =
(i != 0 && trt_mode == TrtTestMode::kImplicitBatch)
(i != 0 && trt_mode_ == TrtTestMode::kImplicitBatch)
? errors::InvalidArgument(
StrCat("Batch size doesn't match for tensor ",
node_input[i].name,
@ -2134,19 +2134,19 @@ TEST_P(OpConverterTest1, ConvertFusedBatchNorm) {
"converter batch size: 3 vs 2"))
: Status::OK();
std::vector<int> partial_input_shape;
if (i == 0 && trt_mode == TrtTestMode::kDynamicShape &&
if (i == 0 && trt_mode_ == TrtTestMode::kDynamicShape &&
!p.keep_channel_unknown) {
// keep channel dim static (known)
partial_input_shape.resize(4, -1);
partial_input_shape[1] = node_input[i].dims[1];
}
AddTestTensor(node_input[i].name, node_input[i].dims, tf_type,
AddTestTensor(node_input[i].name, node_input[i].dims, tf_type_,
node_input[i].val, partial_input_shape,
expected_status);
} else {
AddTestWeights(node_input[i].name, node_input[i].dims,
node_input[i].val, tf_type);
node_input[i].val, tf_type_);
}
}
TestOpConverter("my_batchnorm", node_def, node_input[0].dims,
@ -2154,12 +2154,12 @@ TEST_P(OpConverterTest1, ConvertFusedBatchNorm) {
ArrayFloatNear(expected_output));
}
}
} // namespace convert
}
TEST_P(OpConverterTest1, ConvertTranspose) {
// Get the NodeDef for Transpose.
Scope s = Scope::NewRootScope();
auto input = ops::Placeholder(s.WithOpName("input"), tf_type);
auto input = ops::Placeholder(s.WithOpName("input"), tf_type_);
auto weights = ops::Placeholder(s.WithOpName("weights"), DT_INT32);
auto transpose = ops::Transpose(s.WithOpName("my_transpose"), input, weights);
const NodeDef& node_def = transpose.operation.node()->def();
@ -2187,13 +2187,13 @@ TEST_P(OpConverterTest1, ConvertTranspose) {
{},
{3, 2, 1, 1},
{3, 2, 1, 0},
(trt_mode == TrtTestMode::kImplicitBatch)
(trt_mode_ == TrtTestMode::kImplicitBatch)
? Status(error::UNIMPLEMENTED,
"Transpose at batch dimension is not supported")
: Status::OK()},
TestParamBase{{1, 1, 2, 3}, {}, {1, 3, 1, 2}, {0, 3, 1, 2}},
};
if (trt_mode == TrtTestMode::kDynamicShape) {
if (trt_mode_ == TrtTestMode::kDynamicShape) {
// Dynamic shape tests where some shapes are known
test_params.push_back(TestParamBase{
{1, 1, 2, 3}, {-1, 1, 2, -1}, {1, 3, 1, 2}, {0, 3, 1, 2}});
@ -2317,12 +2317,12 @@ TEST_F(OpConverterTest, ConvertReshape) {
TEST_P(OpConverterTest1, ConvertShape) {
// Get the NodeDef for Shape op.
Scope s = Scope::NewRootScope();
auto input = ops::Placeholder(s.WithOpName("input"), tf_type);
auto input = ops::Placeholder(s.WithOpName("input"), tf_type_);
auto shape = ops::Shape(s.WithOpName("my_shape"), input);
const NodeDef& node_def = shape.operation.node()->def();
Status conversion_status =
(trt_mode == TrtTestMode::kImplicitBatch)
(trt_mode_ == TrtTestMode::kImplicitBatch)
? errors::Unimplemented(
"Shape is only supported for explicit batch mode.")
: Status::OK();
@ -2346,7 +2346,7 @@ TEST_P(OpConverterTest1, ConvertShape) {
// we use for the unit test have no actual input tensor when it is converted
// to a TensorRT network.
int n_elements = 0;
if (input_is_weight(p) || trt_mode != TrtTestMode::kExplicitBatch) {
if (input_is_weight(p) || trt_mode_ != TrtTestMode::kExplicitBatch) {
// Calculate the number of elements for adding input data.
n_elements = std::accumulate(p.input_dims.begin(), p.input_dims.end(), 1,
std::multiplies<int>());
@ -2355,7 +2355,7 @@ TEST_P(OpConverterTest1, ConvertShape) {
if (!input_is_weight(p)) {
AddTestTensor("input", p.input_dims, input_val);
} else {
AddTestWeights("input", p.input_dims, input_val, tf_type);
AddTestWeights("input", p.input_dims, input_val, tf_type_);
}
TestOpConverter("my_shape", node_def, p.expected_output_dims, p.status,
p.runtime_status, ElementsAreArray(p.input_dims),
@ -2620,7 +2620,7 @@ TEST_P(OpConverterTest2, ConvertBiasAdd) {
for (const string& data_format : {"NHWC", "NCHW"}) {
for (const int trt_input_rank : {1, 2, 3, 4}) {
Reset();
NodeDef node_def = get_biasadd_nodedef(data_format, tf_type);
NodeDef node_def = get_biasadd_nodedef(data_format, tf_type_);
// Add input, dims_array will be like {2, 1, ..., 1, 3}
std::vector<int32> dims_array(trt_input_rank + 1, 1);
@ -2642,7 +2642,7 @@ TEST_P(OpConverterTest2, ConvertBiasAdd) {
for (int i = 0; i < channel_size; ++i) {
bias[i] = i + 1; // bias will be {1, 2, 3, ...}
}
AddTestWeights("weights", {channel_size}, bias, tf_type);
AddTestWeights("weights", {channel_size}, bias, tf_type_);
// Build and run the engine.
std::vector<float> output_data;
@ -2678,7 +2678,7 @@ NodeDef GetBinaryOpNodeDef(DataType dtype) {
TEST_P(OpConverterTest2, ConvertBinary) {
{
AttrValue dtype;
dtype.set_type(tf_type);
dtype.set_type(tf_type_);
// Both inputs are weights.
Reset();
NodeDef node_def =
@ -2723,19 +2723,19 @@ TEST_P(OpConverterTest2, ConvertBinary) {
if (!op_test_info.count(op_name)) {
FAIL() << "Binary op test map does not contain op " << op_name;
}
NodeDef node_def = op_test_info[op_name].first(tf_type);
NodeDef node_def = op_test_info[op_name].first(tf_type_);
std::vector<std::string> input_names;
std::vector<std::vector<int>> input_dims;
std::vector<std::vector<float>> input_values;
if (operand_1_is_tensor) {
AddTestTensor("input1", {2, 1, 2}, {3, 6, 3, 6});
} else {
AddTestWeights("input1", {1, 2}, std::vector<float>{3, 6}, tf_type);
AddTestWeights("input1", {1, 2}, std::vector<float>{3, 6}, tf_type_);
}
if (operand_2_is_tensor) {
AddTestTensor("input2", {2, 2, 1}, {2, 3, 2, 3});
} else {
AddTestWeights("input2", {2, 1}, std::vector<float>{2, 3}, tf_type);
AddTestWeights("input2", {2, 1}, std::vector<float>{2, 3}, tf_type_);
}
TestOpConverter("my_binary", node_def, {2, 2, 2}, Status::OK(),
Status::OK(),
@ -2942,10 +2942,10 @@ TEST_P(OpConverterTest2, ConvertSquare) {
// Input is weights, should fail.
Reset();
Scope s = Scope::NewRootScope();
auto input = ops::Placeholder(s.WithOpName("input"), tf_type);
auto input = ops::Placeholder(s.WithOpName("input"), tf_type_);
auto square = ops::Square(s.WithOpName("my_square"), input);
NodeDef node_def = square.operation.node()->def();
AddTestWeights("input", {1, 2, 3}, {1, 2, 3, 4, -5, 6}, tf_type);
AddTestWeights("input", {1, 2, 3}, {1, 2, 3, 4, -5, 6}, tf_type_);
RunValidationAndConversion(
node_def, error::UNIMPLEMENTED,
"The input \"x\" for Square must be a tensor, at my_square");
@ -2954,7 +2954,7 @@ TEST_P(OpConverterTest2, ConvertSquare) {
Reset();
Scope s = Scope::NewRootScope();
auto input = ops::Placeholder(s.WithOpName("input"), tf_type);
auto input = ops::Placeholder(s.WithOpName("input"), tf_type_);
auto square = ops::Square(s.WithOpName("my_square"), input);
NodeDef node_def = square.operation.node()->def();
@ -2967,7 +2967,7 @@ TEST_P(OpConverterTest2, ConvertSquare) {
inputs[i] = value;
expected_outputs[i] = value * value;
}
AddTestTensor("input", {1, 1, 20}, tf_type, inputs);
AddTestTensor("input", {1, 1, 20}, tf_type_, inputs);
TestOpConverter("my_square", node_def, {1, 1, 20}, Status::OK(), Status::OK(),
ArrayFloatNear(expected_outputs, 0));
@ -3094,7 +3094,7 @@ TEST_P(OpConverterTest1, ConvertActivation) {
{
// Input is weights, should fail.
Reset();
const NodeDef& node_def = CreateUnaryOp<ops::Relu>(tf_type);
const NodeDef& node_def = CreateUnaryOp<ops::Relu>(tf_type_);
AddTestWeights<int32>("input", {1, 2, 3}, {-3, -2, -1, 0, 1, 2});
RunValidationAndConversion(
node_def, error::UNIMPLEMENTED,
@ -3151,7 +3151,7 @@ TEST_P(OpConverterTest1, ConvertActivation) {
FAIL() << "Activation op test map does not contain op " << op_name;
}
Reset();
NodeDef node_def = op_map[op_name].first(tf_type);
NodeDef node_def = op_map[op_name].first(tf_type_);
const std::vector<float> input = {-100, -2, -1, 0, 1, 88};
AddTestTensor("input", p.input_dims, input);
@ -3179,7 +3179,7 @@ TEST_P(OpConverterTest1, ConvertActivation) {
TEST_P(OpConverterTest1, ConvertExpandDims) {
// Get the NodeDef for ExpandDims.
Scope s = Scope::NewRootScope();
auto input = ops::Placeholder(s.WithOpName("input"), tf_type);
auto input = ops::Placeholder(s.WithOpName("input"), tf_type_);
auto weights = ops::Placeholder(s.WithOpName("weights"), DT_INT32);
auto expanddims =
ops::ExpandDims(s.WithOpName("my_expanddims"), input, weights);
@ -3207,7 +3207,7 @@ TEST_P(OpConverterTest1, ConvertExpandDims) {
{},
{1, 1, 1, 2, 3},
{0},
trt_mode == TrtTestMode::kImplicitBatch
trt_mode_ == TrtTestMode::kImplicitBatch
? Status(error::UNIMPLEMENTED,
"TensorRT does not allow manipulation of the "
"batch dimension, at my_expanddims")
@ -3216,7 +3216,7 @@ TEST_P(OpConverterTest1, ConvertExpandDims) {
{},
{1, 1, 1, 2, 3},
{-5},
trt_mode == TrtTestMode::kImplicitBatch
trt_mode_ == TrtTestMode::kImplicitBatch
? Status(error::UNIMPLEMENTED,
"TensorRT does not allow manipulation of the "
"batch dimension, at my_expanddims")
@ -3254,7 +3254,7 @@ TEST_P(OpConverterTest1, ConvertExpandDims) {
}
TEST_P(OpConverterTest1, ConvertSqueeze) {
const bool use_implicit_batch = (trt_mode == TrtTestMode::kImplicitBatch);
const bool use_implicit_batch = (trt_mode_ == TrtTestMode::kImplicitBatch);
// Get the NodeDef for Squeeze.
auto get_squeeze_nodedef = [](std::vector<int> axes,
DataType tf_type) -> NodeDef {
@ -3277,7 +3277,7 @@ TEST_P(OpConverterTest1, ConvertSqueeze) {
{}, // input partial dims
{2, 3}, // expected output dims
{}, // axis
trt_mode == TrtTestMode::kExplicitBatch
trt_mode_ == TrtTestMode::kExplicitBatch
? Status::OK()
: Status{error::UNIMPLEMENTED,
"Squeeze is not implemented for empty squeeze_dims, at "
@ -3336,7 +3336,7 @@ TEST_P(OpConverterTest1, ConvertSqueeze) {
"Dimension 2 with size 2 cannot be squeezed because it must be "
"size 1, at my_squeeze"}};
if (trt_mode == TrtTestMode::kDynamicShape) {
if (trt_mode_ == TrtTestMode::kDynamicShape) {
// In this test we try to squeeze axis=2 which has size > 1. In dynamic
// shape mode the converter sees only -1, so it cannot catch this error.
squeeze_non_singleton.status = Status::OK(); // conversion status
@ -3351,7 +3351,7 @@ TEST_P(OpConverterTest1, ConvertSqueeze) {
for (TestParamBase p : test_params) {
SCOPED_TRACE(p);
Reset();
NodeDef node_def = get_squeeze_nodedef(p.param, tf_type);
NodeDef node_def = get_squeeze_nodedef(p.param, tf_type_);
AddTestTensor("input", p.input_dims, {1, 2, 3, 4, 5, 6},
p.partial_input_dims);
TestOpConverter("my_squeeze", node_def, p.expected_output_dims, p.status,
@ -4106,14 +4106,14 @@ TEST_F(OpConverterTest, ConvertSlice) {
TEST_P(OpConverterTest1, ConvertConv2D) {
// Get nodedef for Conv2D layer.
DataType tf_type_loc = tf_type;
DataType tf_type = tf_type_;
auto get_conv2d_nodedef =
[tf_type_loc](std::vector<int> strides = {1, 1, 1, 1},
[tf_type](std::vector<int> strides = {1, 1, 1, 1},
string padding = "SAME", string data_format = "NCHW",
std::vector<int> dilations = {1, 1, 1, 1}) -> NodeDef {
Scope s = Scope::NewRootScope();
auto input = ops::Placeholder(s.WithOpName("input"), tf_type_loc);
auto filter = ops::Placeholder(s.WithOpName("weights"), tf_type_loc);
auto input = ops::Placeholder(s.WithOpName("input"), tf_type);
auto filter = ops::Placeholder(s.WithOpName("weights"), tf_type);
ops::Conv2D::Attrs attrs =
ops::Conv2D::Attrs().DataFormat(data_format).Dilations(dilations);
auto conv2d = ops::Conv2D(s.WithOpName("my_conv2d"), input, filter, strides,
@ -4206,12 +4206,12 @@ TEST_P(OpConverterTest1, ConvertConv2D) {
node_def, error::UNIMPLEMENTED,
"Stride must be 1 for batch and channel dimensions, at my_conv2d");
}
if (trt_mode == TrtTestMode::kDynamicShape) {
if (trt_mode_ == TrtTestMode::kDynamicShape) {
Reset();
NodeDef node_def = get_conv2d_nodedef();
// Channel dim unknown, should fail.
AddTestTensorWithTFDims("input", {-1, -1, -1, -1},
TfDataTypeToTrt(tf_type));
TfDataTypeToTrt(tf_type_));
AddTestWeights<float>("weights", {1, 2, 1, 1}, {-1, 1});
RunValidationAndConversion(
node_def, error::INVALID_ARGUMENT,
@ -4316,15 +4316,15 @@ TEST_P(OpConverterTest1, ConvertConv2D) {
get_conv2d_nodedef(ok_params[i].strides, ok_params[i].padding,
ok_params[i].data_format, ok_params[i].dilations);
std::vector<int> partial_input_shape;
if (trt_mode == TrtTestMode::kDynamicShape) {
if (trt_mode_ == TrtTestMode::kDynamicShape) {
// The channel dim cannot have unknown size, fix that.
partial_input_shape.resize(ok_params[i].input_dims.size(), -1);
int channel_id = (ok_params[i].data_format == "NCHW") ? 1 : 3;
partial_input_shape[channel_id] = ok_params[i].input_dims[channel_id];
}
AddTestTensor("input", ok_params[i].input_dims, tf_type, ok_params[i].input,
partial_input_shape);
AddTestTensor("input", ok_params[i].input_dims, tf_type_,
ok_params[i].input, partial_input_shape);
AddTestWeights<float>("weights", ok_params[i].filter_dims,
ok_params[i].filter);
@ -4851,7 +4851,7 @@ TEST_P(OpConverterTest1, ConvertPool) {
for (int nDim : test_nDims) {
// Input is weights, should fail.
Reset();
NodeDef node_def = get_pool_nodedef(tf_type, nDim);
NodeDef node_def = get_pool_nodedef(tf_type_, nDim);
AddTestWeights<float>("input", {1, 1, 1, 2, 3}, {1, 2, 3, 4, 5, 6});
RunValidationAndConversion(node_def, error::UNIMPLEMENTED,
@ -4960,7 +4960,7 @@ TEST_P(OpConverterTest1, ConvertPool) {
for (bool is_max_pooling : {true, false}) {
Reset();
NodeDef node_def =
get_pool_nodedef(tf_type, nDim, ksize, strides, p.padding,
get_pool_nodedef(tf_type_, nDim, ksize, strides, p.padding,
data_format, is_max_pooling);
AddTestTensor("input", input_dims, input);
TestOpConverter("my_pool", node_def, expected_output_dims, Status::OK(),
@ -5022,7 +5022,7 @@ TEST_F(OpConverterTest, ConvertTopK) {
TEST_P(OpConverterTest3, ConvertGather) {
// Get the NodeDef for GatherV2.
Scope s = Scope::NewRootScope();
auto params = ops::Placeholder(s.WithOpName("params"), tf_type);
auto params = ops::Placeholder(s.WithOpName("params"), tf_type_);
auto indices = ops::Placeholder(s.WithOpName("indices"), DT_INT32);
auto axis = ops::Placeholder(s.WithOpName("axis"), DT_INT32);
auto gather = ops::GatherV2(s.WithOpName("my_gather"), params, indices, axis);
@ -5030,7 +5030,7 @@ TEST_P(OpConverterTest3, ConvertGather) {
{
// Axis is a tensor, should fail.
Reset();
AddTestTensor("params", {1, 1, 2, 3}, tf_type, {});
AddTestTensor("params", {1, 1, 2, 3}, tf_type_, {});
AddTestTensor("indices", {1, 2}, DT_INT32, {});
AddTestTensor("axis", {1}, DT_INT32, {});
RunValidationAndConversion(
@ -5075,7 +5075,7 @@ TEST_P(OpConverterTest3, ConvertGather) {
/*expected_output_shape=*/{2, 1, 1, 3},
/*expected_output=*/{4, 5, 6, 1, 2, 3},
/*params_is_tensor=*/true,
trt_mode == TrtTestMode::kImplicitBatch
trt_mode_ == TrtTestMode::kImplicitBatch
? Status{error::UNIMPLEMENTED,
"TensorRT does not allow manipulation of the"
" batch dimension, at my_gather"}
@ -5088,7 +5088,7 @@ TEST_P(OpConverterTest3, ConvertGather) {
/*expected_output_shape=*/{2, 1, 2, 1},
/*expected_output=*/{3, 1, 6, 4},
/*params_is_tensor=*/true,
trt_mode == TrtTestMode::kImplicitBatch
trt_mode_ == TrtTestMode::kImplicitBatch
? Status{error::UNIMPLEMENTED,
"Indices must have a batch size of 1 when params"
" is a tensor."}
@ -5102,7 +5102,7 @@ TEST_P(OpConverterTest3, ConvertGather) {
/*expected_output_shape=*/{2, 1, 2},
/*expected_output=*/{2, 3, 5, 6},
/*params_is_tensor=*/false,
trt_mode == TrtTestMode::kImplicitBatch
trt_mode_ == TrtTestMode::kImplicitBatch
? Status{error::UNIMPLEMENTED,
"The input axis must be zero when params is a"
" weight."}
@ -5115,13 +5115,13 @@ TEST_P(OpConverterTest3, ConvertGather) {
/*expected_output_shape=*/{2},
/*expected_output=*/{2, 4},
/*params_is_tensor=*/true,
trt_mode == TrtTestMode::kImplicitBatch // conversion_status
trt_mode_ == TrtTestMode::kImplicitBatch // conversion_status
? Status{error::UNIMPLEMENTED,
"TensorRT does not allow manipulation of the "
"batch dimension, at my_gather"}
: Status::OK(),
Status::OK(), // runtime_status
trt_mode == TrtTestMode::kImplicitBatch // add_index_status
trt_mode_ == TrtTestMode::kImplicitBatch // add_index_status
? Status{error::INVALID_ARGUMENT,
"Batch size doesn't match for tensor indices: "
"Provided batch size does not match converter "
@ -5236,7 +5236,7 @@ TEST_P(OpConverterTest3, ConvertGather) {
if (p.params_is_tensor) {
AddTestTensor("params", p.params_shape, params_input);
} else {
AddTestWeights("params", p.params_shape, params_input, tf_type);
AddTestWeights("params", p.params_shape, params_input, tf_type_);
}
AddTestTensor("indices", p.indices_shape, DT_INT32, p.indices, {},
p.add_index_status);
@ -5276,7 +5276,7 @@ TEST_P(OpConverterTest1, ConvertReduce) {
{
// Input is weights, should fail.
Reset();
const NodeDef node_def = CreateReduceOp<ops::Sum>(tf_type, false);
const NodeDef node_def = CreateReduceOp<ops::Sum>(tf_type_, false);
AddTestWeights<float>("input", {1, 2, 3}, {-3, -2, -1, 0, 1, 2});
AddTestWeights<int32>("axis", {1}, {1});
RunValidationAndConversion(
@ -5286,7 +5286,7 @@ TEST_P(OpConverterTest1, ConvertReduce) {
{
// Axis is weights, should fail.
Reset();
const NodeDef node_def = CreateReduceOp<ops::Sum>(tf_type, false);
const NodeDef node_def = CreateReduceOp<ops::Sum>(tf_type_, false);
AddTestTensor("input", {1, 2, 3}, {-3, -2, -1, 0, 1, 2});
AddTestTensor("axis", {1}, DT_INT32, {1});
RunValidationAndConversion(
@ -5346,7 +5346,7 @@ TEST_P(OpConverterTest1, ConvertReduce) {
for (auto p : params) {
SCOPED_TRACE(StrCat(op.name, keep_dims ? "keep_dims" : ""));
Reset();
NodeDef node_def = op.get_node(tf_type, keep_dims);
NodeDef node_def = op.get_node(tf_type_, keep_dims);
AddTestTensor("input", p.input_dims, p.input_values);
AddTestWeights<int32>("axis", {static_cast<int>(p.axis.size())},
@ -5366,7 +5366,7 @@ TEST_P(OpConverterTest1, ConvertReduce) {
int ax_positive = ax >= 0 ? ax : ax + rank;
// Zero marks elements that we will remove later.
expected_output_dims[ax_positive] = keep_dims ? 1 : 0;
if (trt_mode == TrtTestMode::kImplicitBatch &&
if (trt_mode_ == TrtTestMode::kImplicitBatch &&
(ax == 0 || ax == -rank)) {
p.conversion_status = errors::Unimplemented(
"TensorRT does not allow manipulation of the batch "
@ -5402,7 +5402,7 @@ TEST_P(OpConverterTest1, ConvertUnary) {
{
// Input is weights, should fail.
Reset();
const NodeDef node_def = CreateUnaryOp<ops::Neg>(tf_type);
const NodeDef node_def = CreateUnaryOp<ops::Neg>(tf_type_);
AddTestWeights<float>("input", {1, 2, 3}, {-3, -2, -1, 0, 1, 2});
RunValidationAndConversion(
node_def, error::UNIMPLEMENTED,
@ -5458,7 +5458,7 @@ TEST_P(OpConverterTest1, ConvertUnary) {
if (!op_map.count(op_name)) {
FAIL() << "Unary op test map does not contain op " << op_name;
}
NodeDef node_def = op_map[op_name].first(tf_type);
NodeDef node_def = op_map[op_name].first(tf_type_);
// TODO(bixia): we assume this test is only instantiated for DT_FLOAT for
// now. Need to find a better way to express input and output types.
@ -5466,7 +5466,7 @@ TEST_P(OpConverterTest1, ConvertUnary) {
// TODO(tfeher): improve tests by defining an expected output data type and
// check that. Currently only the shape and values of the output are
// checked.
DataType input_tf_type = op_name == "Cast" ? DT_HALF : tf_type;
DataType input_tf_type = op_name == "Cast" ? DT_HALF : tf_type_;
std::vector<float> input_values{-0.9f, 0.6f, 0.0f, -3.5f, 100.0f, 2.9f};
AddTestTensor("input", p.input_dims, input_tf_type, input_values);
@ -6033,7 +6033,7 @@ TEST_P(OpConverterTest2, ConvertPack) {
/*axis=*/1,
/*expected_output_dims=*/{1, 2, 2, 3},
/*expected_output=*/InitTestVector<float>(12),
trt_mode == TrtTestMode::kImplicitBatch
trt_mode_ == TrtTestMode::kImplicitBatch
? Status{error::UNIMPLEMENTED,
"The input \"values_1\" for Pack must be a tensor, at "
"my_pack"}
@ -6059,7 +6059,7 @@ TEST_P(OpConverterTest2, ConvertPack) {
/*axis=*/-4,
/*expected_output_dims=*/{2, 1, 2, 3},
/*expected_output=*/InitTestVector<float>(12),
trt_mode == TrtTestMode::kImplicitBatch
trt_mode_ == TrtTestMode::kImplicitBatch
? Status{error::UNIMPLEMENTED,
"TensorRT does not allow manipulation of the batch "
"dimension, at my_pack"}
@ -6119,7 +6119,7 @@ TEST_P(OpConverterTest2, ConvertPack) {
},
};
// Inputs have inconsistent shapes, should fail.
if (trt_mode != TrtTestMode::kDynamicShape) {
if (trt_mode_ != TrtTestMode::kDynamicShape) {
params.push_back(TestParams{
/*input_shapes=*/{{1, 2, 3}, {1, 3, 2}},
/*partial_input_shapes=*/{{}, {}},
@ -6139,7 +6139,7 @@ TEST_P(OpConverterTest2, ConvertPack) {
// TODO(tfeher) Add dynamic shapes test once TRT handles shape error
// decently
}
if (trt_mode == TrtTestMode::kDynamicShape) {
if (trt_mode_ == TrtTestMode::kDynamicShape) {
// Test with mixed dynamic / static shape input tensors
params.push_back(
TestParams{/*input_shapes=*/{{1, 2, 3}, {1, 2, 3}},
@ -6155,14 +6155,14 @@ TEST_P(OpConverterTest2, ConvertPack) {
const int num_inputs = p.input_shapes.size();
EXPECT_EQ(num_inputs, p.input_values.size());
NodeDef node_def = GetPackNodeDef(tf_type, num_inputs, p.axis);
NodeDef node_def = GetPackNodeDef(tf_type_, num_inputs, p.axis);
// Create inputs.
for (int j = 0; j < num_inputs; ++j) {
if (j == 1 && p.input_1_is_weight) {
AddTestWeights(StrCat("values_", j), p.input_shapes[j],
p.input_values[j], tf_type);
p.input_values[j], tf_type_);
} else {
AddTestTensor(StrCat("values_", j), p.input_shapes[j], tf_type,
AddTestTensor(StrCat("values_", j), p.input_shapes[j], tf_type_,
p.input_values[j], p.partial_input_shapes[j]);
}
}
@ -6690,7 +6690,7 @@ TEST_P(OpConverterTest2, ConvertSquaredDifference) {
{
// Input is a weight, should fail.
Reset();
NodeDef node_def = GetSquaredDifferenceNodeDef(tf_type);
NodeDef node_def = GetSquaredDifferenceNodeDef(tf_type_);
AddTestWeights<float>("x", {1, 2, 3}, {1, 2, 3, 4, 5, 6});
AddTestTensor("y", {1, 1, 2, 3});
RunValidationAndConversion(node_def, error::UNIMPLEMENTED,
@ -6717,7 +6717,7 @@ TEST_P(OpConverterTest2, ConvertSquaredDifference) {
/*value_y=*/std::vector<float>(7 * 5, 0),
/*expected_output_dims=*/{1, 1, 2, 3},
/*expected_output=*/common_input,
trt_mode == TrtTestMode::kDynamicShape
trt_mode_ == TrtTestMode::kDynamicShape
? Status::OK()
: errors::InvalidArgument("Infeasible broadcast scheme"),
errors::Internal(
@ -6743,7 +6743,7 @@ TEST_P(OpConverterTest2, ConvertSquaredDifference) {
for (auto p : params) {
Reset();
NodeDef node_def = GetSquaredDifferenceNodeDef(tf_type);
NodeDef node_def = GetSquaredDifferenceNodeDef(tf_type_);
AddTestTensor("x", p.dims_x, p.value_x);
AddTestTensor("y", p.dims_y, p.value_y);
TestOpConverter("my_squared_diff", node_def, p.expected_output_dims,