From be917027e37c5e8f21f6ba07f24bdbf072cf6dfd Mon Sep 17 00:00:00 2001 From: Mingsheng Hong Date: Mon, 26 Mar 2018 10:51:21 -0700 Subject: [PATCH] Added experimental C APIs to build a stack of dataset + iterator nodes that reads imagenet TFRecord files. PiperOrigin-RevId: 190488817 --- tensorflow/c/BUILD | 2 + tensorflow/c/c_api_experimental.cc | 7218 ++++++++++++++++++++++++++++++- tensorflow/c/c_api_experimental.h | 31 +- tensorflow/c/c_api_experimental_test.cc | 84 +- tensorflow/c/testdata/tf_record | Bin 0 -> 417114 bytes 5 files changed, 7155 insertions(+), 180 deletions(-) create mode 100644 tensorflow/c/testdata/tf_record diff --git a/tensorflow/c/BUILD b/tensorflow/c/BUILD index d096647..426f97b 100644 --- a/tensorflow/c/BUILD +++ b/tensorflow/c/BUILD @@ -220,6 +220,7 @@ tf_cc_test( name = "c_api_experimental_test", size = "small", srcs = ["c_api_experimental_test.cc"], + data = ["testdata/tf_record"], linkopts = select({ "//tensorflow:darwin": ["-headerpad_max_install_names"], "//conditions:default": [], @@ -230,6 +231,7 @@ tf_cc_test( deps = [ ":c_api_experimental", ":c_test_util", + "//tensorflow/core:lib", "//tensorflow/core:test", "//tensorflow/core:test_main", ], diff --git a/tensorflow/c/c_api_experimental.cc b/tensorflow/c/c_api_experimental.cc index 8593a8e..1c809cb 100644 --- a/tensorflow/c/c_api_experimental.cc +++ b/tensorflow/c/c_api_experimental.cc @@ -22,10 +22,15 @@ limitations under the License. #include "tensorflow/core/lib/strings/strcat.h" #include "tensorflow/core/protobuf/config.pb.h" +using tensorflow::FunctionDef; using tensorflow::Node; using tensorflow::NodeBuilder; using tensorflow::Status; -using tensorflow::Tensor; + +namespace { +typedef std::unique_ptr + UniqueFuncPtr; +} // struct TF_Operation { tensorflow::Node node; }; static TF_Operation* ToTF_Operation(Node* node) { @@ -102,8 +107,7 @@ void TF_ShutdownTPU(TF_Session* session, TF_Status* status) { /*run_metadata*/ nullptr, status); } -TF_CAPI_EXPORT extern const char* TF_GraphDebugString(TF_Graph* graph, - size_t* len) { +const char* TF_GraphDebugString(TF_Graph* graph, size_t* len) { tensorflow::mutex_lock c(graph->mu); const auto& debug_str = graph->graph.ToGraphDefDebug().DebugString(); *len = debug_str.size(); @@ -112,55 +116,56 @@ TF_CAPI_EXPORT extern const char* TF_GraphDebugString(TF_Graph* graph, return ret; } -// TODO(hongm): Replace this will a real implementation. -static tensorflow::Status BuildDatasetTest(TF_Graph* dataset_graph, - Node** dataset_node) { - tensorflow::mutex_lock c(dataset_graph->mu); - Tensor const_t(tensorflow::DT_INT32, tensorflow::TensorShape({})); - const_t.flat()(0) = 1; - - Node* const_node; - TF_RETURN_IF_ERROR(NodeBuilder("Const", "Const") - .Attr("dtype", tensorflow::DT_INT32) - .Attr("value", const_t) - .Finalize(&dataset_graph->graph, &const_node)); - - std::vector input_list; - input_list.push_back(NodeBuilder::NodeOut(const_node, 0)); - - return NodeBuilder("TensorDataset", "TensorDataset") - .Input(input_list) - .Attr("Toutput_types", {tensorflow::DT_INT32}) - .Attr("output_shapes", {tensorflow::TensorShapeProto()}) - .Finalize(&dataset_graph->graph, dataset_node); -} - -// On success, returns a newly created TF_Function instance from -// `text_proto`. It must be deleted by calling TF_DeleteFunction. -static TF_Function* CreateFunctionFromTextProto(const char* text_proto, - TF_Status* status) { - tensorflow::FunctionDef fdef; - if (!tensorflow::protobuf::TextFormat::ParseFromString(text_proto, &fdef)) { +// On success, returns a set of TF_Function instances from `text_proto` of +// GraphDef type. These functions must be deleted by calling TF_DeleteFunction. +// +// If `mutate_proto_func` is non-NULL, run it over each FunctionDef proto, +// before creating a TF_Function out of the possibly mutated proto. +static std::vector CreateFunctionsFromTextProto( + const char* text_proto, + std::function* mutate_proto_func, TF_Status* status) { + tensorflow::GraphDef gdef; + if (!tensorflow::protobuf::TextFormat::ParseFromString(text_proto, &gdef)) { status->status = tensorflow::errors::Internal( - "Invalid text proto for FunctionDef: ", text_proto); - return nullptr; + "Invalid text proto for GraphDef: ", text_proto); + return {}; + } + const auto& fdef_lib = gdef.library(); + if (fdef_lib.gradient_size() > 0) { + status->status = tensorflow::errors::Internal( + "GradientDef is not supported in reading Dataset related functions: ", + text_proto); + return {}; } - std::vector binary_proto_buf(fdef.ByteSizeLong()); - fdef.SerializeToArray(binary_proto_buf.data(), binary_proto_buf.size()); - return TF_FunctionImportFunctionDef(binary_proto_buf.data(), - binary_proto_buf.size(), status); + std::vector ret; + for (const auto& fdef : fdef_lib.function()) { + // Make a copy so that we can mutate it. + FunctionDef fdef_to_load = fdef; + if (mutate_proto_func) { + (*mutate_proto_func)(&fdef_to_load); + } + VLOG(1) << "Adding func to graph: " << fdef_to_load.DebugString(); + std::vector binary_proto_buf(fdef_to_load.ByteSizeLong()); + fdef_to_load.SerializeToArray(binary_proto_buf.data(), + binary_proto_buf.size()); + auto func = TF_FunctionImportFunctionDef(binary_proto_buf.data(), + binary_proto_buf.size(), status); + if (!status->status.ok()) return {}; + ret.push_back(UniqueFuncPtr(func, TF_DeleteFunction)); + } + return ret; } -// On success, returns a newly created TF_Function instance from `proto_file`, -// and sets `dataset_name` to the created dataset name. The returned function -// must be deleted by calling TF_DeleteFunction. -// -// TODO(hongm): Support reading the file given by `proto_file`. -static TF_Function* LoadDatasetFunction(const char* proto_file, - std::string* dataset_name, - TF_Status* status) { +// On success, returns a newly created TF_Function instance encoding a dataset +// node stack that returns a sequence of 3 floats, and sets `dataset_name` to +// the created dataset name. The returned function must be deleted by calling +// TF_DeleteFunction. +static UniqueFuncPtr CreateFakeDatasetFunction(std::string* dataset_name, + TF_Status* status) { const char* func_def = R"PREFIX( -signature { +library { + function { + signature { name: "_make_dataset_d8de2712" output_arg { name: "TensorSliceDataset" @@ -217,112 +222,7029 @@ signature { ret { key: "TensorSliceDataset" value: "TensorSliceDataset:handle:0" - })PREFIX"; + } + } +} +)PREFIX"; *dataset_name = "_make_dataset_d8de2712"; - return CreateFunctionFromTextProto(func_def, status); + auto functions = CreateFunctionsFromTextProto( + func_def, /*mutate_proto_func*/ nullptr, status); + DCHECK_EQ(functions.size(), 1); + return std::move(functions[0]); } -// TODO(hongm): Use `file_path` in the implementation. -TF_Operation* TF_MakeIteratorGetNextWithDatasets(TF_Graph* graph, - const char* file_path, - TF_Function** dataset_func, - TF_Status* status) { - tensorflow::Status s; - - // We can parameterize the function name, if we ever need more than 1 - // iterators in a graph. - const std::string dataset_name = "UNIQUE_DATASET"; - - std::unique_ptr dataset_graph( - TF_NewGraph(), TF_DeleteGraph); - Node* dataset_node = nullptr; - s = BuildDatasetTest(dataset_graph.get(), &dataset_node); - if (!s.ok()) { - status->status = s; - return nullptr; - } - - TF_Output output{ToTF_Operation(dataset_node), 0}; - std::unique_ptr result_func( - TF_GraphToFunction(dataset_graph.get(), dataset_name.c_str(), - /*append_hash_to_fn_name*/ false, - /*num_opers*/ -1, - /*opers*/ nullptr, - /*numinputs*/ 0, - /*inputs*/ nullptr, - /*noutputs*/ 1, - /*outputs*/ &output, - /*outputnames*/ nullptr, - /*functionoptions*/ nullptr, "", status), - TF_DeleteFunction); - if (!status->status.ok()) { - return nullptr; - } - - TF_GraphCopyFunction(graph, result_func.get(), /*gradient*/ nullptr, status); - - if (!status->status.ok()) { - return nullptr; - } - - tensorflow::mutex_lock c(graph->mu); - - tensorflow::NameAttrList func; - func.set_name(dataset_name); - // Run the iterator node on CPU. - Node* oneshot_iterator_node; - std::vector output_shape_list; - output_shape_list.push_back(tensorflow::TensorShapeProto()); - s = NodeBuilder("OneShotIterator", "OneShotIterator") - .Device("/device:CPU:0") - .Attr("container", "") - .Attr("dataset_factory", func) - .Attr("output_types", {tensorflow::DT_INT32}) - .Attr("output_shapes", output_shape_list) - .Attr("shared_name", "") - .Finalize(&graph->graph, &oneshot_iterator_node); - if (!s.ok()) { - status->status = s; - return nullptr; - } - // Run shape inference function for each newly added node, so that more - // subsequent nodes can be added to the graph via C API (TF_NewOperation()). - s = graph->refiner.AddNode(oneshot_iterator_node); - if (!s.ok()) { - status->status = s; - return nullptr; - } - - // Run the iterator node on CPU. - Node* getnext_node; - s = NodeBuilder("IteratorGetNext", "IteratorGetNext") - .Input(oneshot_iterator_node) - .Device("/device:CPU:0") - .Attr("output_types", {tensorflow::DT_INT32}) - .Attr("output_shapes", output_shape_list) - .Finalize(&graph->graph, &getnext_node); - if (!s.ok()) { - status->status = s; - return nullptr; +// On success, returns a set of TF_Function instances encoding a dataset +// node stack that reads a Imagenet TFRecordFile dataset from `file_path`, and +// sets `dataset_name` to the created dataset name. The returned functions must +// be deleted by calling TF_DeleteFunction. +static std::vector CreateImagenetDatasetFunctions( + const char* file_path, std::string* dataset_name, TF_Status* status) { + const char* func_def = R"PREFIX( +library { + function { + signature { + name: "tf_map_func_91295dea" + input_arg { + name: "arg0" + type: DT_STRING + } + output_arg { + name: "FlatMapDataset" + type: DT_VARIANT + } + description: "A wrapper for Defun that facilitates shape inference." + is_stateful: true + } + node_def { + name: "flat_filenames/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -1 + } + } + } + } + node_def { + name: "flat_filenames" + op: "Reshape" + input: "arg0" + input: "flat_filenames/shape:output:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + } + node_def { + name: "TensorSliceDataset" + op: "TensorSliceDataset" + input: "flat_filenames:output:0" + attr { + key: "Toutput_types" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "output_shapes" + value { + list { + shape { + } + } + } + } + } + node_def { + name: "FlatMapDataset" + op: "FlatMapDataset" + input: "TensorSliceDataset:handle:0" + attr { + key: "Targuments" + value { + list { + } + } + } + attr { + key: "f" + value { + func { + name: "tf_map_func_0cc8c35b" + } + } + } + attr { + key: "output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "output_types" + value { + list { + type: DT_STRING + } + } + } + } + ret { + key: "FlatMapDataset" + value: "FlatMapDataset:handle:0" + } } - // Run shape inference function for each newly added node, so that more - // subsequent nodes can be added to the graph via C API (TF_NewOperation()). - s = graph->refiner.AddNode(getnext_node); - if (!s.ok()) { - status->status = s; - return nullptr; + function { + signature { + name: "tf_map_func_0cc8c35b" + input_arg { + name: "arg0" + type: DT_STRING + } + output_arg { + name: "TFRecordDataset" + type: DT_VARIANT + } + description: "A wrapper for Defun that facilitates shape inference." + is_stateful: true + } + node_def { + name: "compression_type" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "" + } + } + } + } + node_def { + name: "buffer_size" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 8388608 + } + } + } + } + node_def { + name: "TFRecordDataset" + op: "TFRecordDataset" + input: "arg0" + input: "compression_type:output:0" + input: "buffer_size:output:0" + } + ret { + key: "TFRecordDataset" + value: "TFRecordDataset:handle:0" + } } + function { + signature { + name: "tf_map_func_74b6b15c" + input_arg { + name: "arg0" + type: DT_STRING + } + output_arg { + name: "Reshape_1" + type: DT_FLOAT + } + output_arg { + name: "sub_1" + type: DT_INT32 + } + description: "A wrapper for Defun that facilitates shape inference." + is_stateful: true + } + node_def { + name: "ParseSingleExample/key_image/class/label" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: -1 + } + } + } + } + node_def { + name: "ParseSingleExample/Reshape/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } + } + node_def { + name: "ParseSingleExample/Reshape" + op: "Reshape" + input: "ParseSingleExample/key_image/class/label:output:0" + input: "ParseSingleExample/Reshape/shape:output:0" + attr { + key: "T" + value { + type: DT_INT64 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + } + node_def { + name: "ParseSingleExample/key_image/class/text" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "" + } + } + } + } + node_def { + name: "ParseSingleExample/Reshape_1/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } + } + node_def { + name: "ParseSingleExample/Reshape_1" + op: "Reshape" + input: "ParseSingleExample/key_image/class/text:output:0" + input: "ParseSingleExample/Reshape_1/shape:output:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + } + node_def { + name: "ParseSingleExample/key_image/encoded" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "" + } + } + } + } + node_def { + name: "ParseSingleExample/Reshape_2/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } + } + node_def { + name: "ParseSingleExample/Reshape_2" + op: "Reshape" + input: "ParseSingleExample/key_image/encoded:output:0" + input: "ParseSingleExample/Reshape_2/shape:output:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + } + node_def { + name: "ParseSingleExample/key_image/format" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "jpeg" + } + } + } + } + node_def { + name: "ParseSingleExample/Reshape_3/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } + } + node_def { + name: "ParseSingleExample/Reshape_3" + op: "Reshape" + input: "ParseSingleExample/key_image/format:output:0" + input: "ParseSingleExample/Reshape_3/shape:output:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + } + node_def { + name: "ParseSingleExample/ParseSingleExample" + op: "ParseSingleExample" + input: "arg0" + input: "ParseSingleExample/Reshape:output:0" + input: "ParseSingleExample/Reshape_1:output:0" + input: "ParseSingleExample/Reshape_2:output:0" + input: "ParseSingleExample/Reshape_3:output:0" + attr { + key: "Tdense" + value { + list { + type: DT_INT64 + type: DT_STRING + type: DT_STRING + type: DT_STRING + } + } + } + attr { + key: "dense_keys" + value { + list { + s: "image/class/label" + s: "image/class/text" + s: "image/encoded" + s: "image/format" + } + } + } + attr { + key: "dense_shapes" + value { + list { + shape { + } + shape { + } + shape { + } + shape { + } + } + } + } + attr { + key: "num_sparse" + value { + i: 5 + } + } + attr { + key: "sparse_keys" + value { + list { + s: "image/object/bbox/xmax" + s: "image/object/bbox/xmin" + s: "image/object/bbox/ymax" + s: "image/object/bbox/ymin" + s: "image/object/class/label" + } + } + } + attr { + key: "sparse_types" + value { + list { + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_INT64 + } + } + } + } + node_def { + name: "Reshape/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } + } + node_def { + name: "Reshape" + op: "Reshape" + input: "ParseSingleExample/ParseSingleExample:dense_values:2" + input: "Reshape/shape:output:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + } + node_def { + name: "decode_image/Substr/pos" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } + } + node_def { + name: "decode_image/Substr/len" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } + } + node_def { + name: "decode_image/Substr" + op: "Substr" + input: "Reshape:output:0" + input: "decode_image/Substr/pos:output:0" + input: "decode_image/Substr/len:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + } + node_def { + name: "decode_image/is_jpeg/Substr/pos" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } + } + node_def { + name: "decode_image/is_jpeg/Substr/len" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } + } + node_def { + name: "decode_image/is_jpeg/Substr" + op: "Substr" + input: "Reshape:output:0" + input: "decode_image/is_jpeg/Substr/pos:output:0" + input: "decode_image/is_jpeg/Substr/len:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + } + node_def { + name: "decode_image/is_jpeg/Equal/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "\377\330\377" + } + } + } + } + node_def { + name: "decode_image/is_jpeg/Equal" + op: "Equal" + input: "decode_image/is_jpeg/Substr:output:0" + input: "decode_image/is_jpeg/Equal/y:output:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + } + node_def { + name: "decode_image/cond_jpeg/Switch" + op: "Switch" + input: "decode_image/is_jpeg/Equal:z:0" + input: "decode_image/is_jpeg/Equal:z:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "decode_image/cond_jpeg/switch_t" + op: "Identity" + input: "decode_image/cond_jpeg/Switch:output_true:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "decode_image/cond_jpeg/switch_f" + op: "Identity" + input: "decode_image/cond_jpeg/Switch:output_false:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "decode_image/cond_jpeg/pred_id" + op: "Identity" + input: "decode_image/is_jpeg/Equal:z:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "decode_image/cond_jpeg/check_jpeg_channels/x" + op: "Const" + input: "^decode_image/cond_jpeg/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/check_jpeg_channels/y" + op: "Const" + input: "^decode_image/cond_jpeg/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 4 + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/check_jpeg_channels" + op: "NotEqual" + input: "decode_image/cond_jpeg/check_jpeg_channels/x:output:0" + input: "decode_image/cond_jpeg/check_jpeg_channels/y:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + } + node_def { + name: "decode_image/cond_jpeg/Assert/Const" + op: "Const" + input: "^decode_image/cond_jpeg/switch_t" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "Channels must be in (None, 0, 1, 3) when decoding JPEG images" + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/Assert/Assert/data_0" + op: "Const" + input: "^decode_image/cond_jpeg/switch_t" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "Channels must be in (None, 0, 1, 3) when decoding JPEG images" + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/Assert/Assert" + op: "Assert" + input: "decode_image/cond_jpeg/check_jpeg_channels:z:0" + input: "decode_image/cond_jpeg/Assert/Assert/data_0:output:0" + attr { + key: "T" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "summarize" + value { + i: 3 + } + } + } + node_def { + name: "decode_image/cond_jpeg/DecodeJpeg" + op: "DecodeJpeg" + input: "decode_image/cond_jpeg/DecodeJpeg/Switch:output_true:0" + input: "^decode_image/cond_jpeg/Assert/Assert" + attr { + key: "acceptable_fraction" + value { + f: 1.0 + } + } + attr { + key: "channels" + value { + i: 3 + } + } + attr { + key: "dct_method" + value { + s: "" + } + } + attr { + key: "fancy_upscaling" + value { + b: true + } + } + attr { + key: "ratio" + value { + i: 1 + } + } + attr { + key: "try_recover_truncated" + value { + b: false + } + } + } + node_def { + name: "decode_image/cond_jpeg/DecodeJpeg/Switch" + op: "Switch" + input: "Reshape:output:0" + input: "decode_image/cond_jpeg/pred_id:output:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_class" + value { + list { + s: "loc:@Reshape" + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/is_png/y" + op: "Const" + input: "^decode_image/cond_jpeg/switch_f" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "\211PN" + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/is_png" + op: "Equal" + input: "decode_image/cond_jpeg/is_png/Switch:output_false:0" + input: "decode_image/cond_jpeg/is_png/y:output:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + } + node_def { + name: "decode_image/cond_jpeg/is_png/Switch" + op: "Switch" + input: "decode_image/Substr:output:0" + input: "decode_image/cond_jpeg/pred_id:output:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_class" + value { + list { + s: "loc:@decode_image/Substr" + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/Switch" + op: "Switch" + input: "decode_image/cond_jpeg/is_png:z:0" + input: "decode_image/cond_jpeg/is_png:z:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/switch_t" + op: "Identity" + input: "decode_image/cond_jpeg/cond_png/Switch:output_true:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/switch_f" + op: "Identity" + input: "decode_image/cond_jpeg/cond_png/Switch:output_false:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/pred_id" + op: "Identity" + input: "decode_image/cond_jpeg/is_png:z:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/DecodePng" + op: "DecodePng" + input: "decode_image/cond_jpeg/cond_png/DecodePng/Switch_1:output_true:0" + attr { + key: "channels" + value { + i: 3 + } + } + attr { + key: "dtype" + value { + type: DT_UINT8 + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/DecodePng/Switch" + op: "Switch" + input: "Reshape:output:0" + input: "decode_image/cond_jpeg/pred_id:output:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_class" + value { + list { + s: "loc:@Reshape" + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/DecodePng/Switch_1" + op: "Switch" + input: "decode_image/cond_jpeg/cond_png/DecodePng/Switch:output_false:0" + input: "decode_image/cond_jpeg/cond_png/pred_id:output:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_class" + value { + list { + s: "loc:@Reshape" + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/is_gif/y" + op: "Const" + input: "^decode_image/cond_jpeg/cond_png/switch_f" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "GIF" + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/is_gif" + op: "Equal" + input: "decode_image/cond_jpeg/cond_png/is_gif/Switch:output_false:0" + input: "decode_image/cond_jpeg/cond_png/is_gif/y:output:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/is_gif/Switch" + op: "Switch" + input: "decode_image/cond_jpeg/is_png/Switch:output_false:0" + input: "decode_image/cond_jpeg/cond_png/pred_id:output:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_class" + value { + list { + s: "loc:@decode_image/Substr" + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/Switch" + op: "Switch" + input: "decode_image/cond_jpeg/cond_png/is_gif:z:0" + input: "decode_image/cond_jpeg/cond_png/is_gif:z:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/switch_t" + op: "Identity" + input: "decode_image/cond_jpeg/cond_png/cond_gif/Switch:output_true:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/switch_f" + op: "Identity" + input: "decode_image/cond_jpeg/cond_png/cond_gif/Switch:output_false:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/pred_id" + op: "Identity" + input: "decode_image/cond_jpeg/cond_png/is_gif:z:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/check_gif_channels/x" + op: "Const" + input: "^decode_image/cond_jpeg/cond_png/cond_gif/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/check_gif_channels/y" + op: "Const" + input: "^decode_image/cond_jpeg/cond_png/cond_gif/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/check_gif_channels" + op: "NotEqual" + input: "decode_image/cond_jpeg/cond_png/cond_gif/check_gif_channels/x:output:0" + input: "decode_image/cond_jpeg/cond_png/cond_gif/check_gif_channels/y:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/check_gif_channels_1/x" + op: "Const" + input: "^decode_image/cond_jpeg/cond_png/cond_gif/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/check_gif_channels_1/y" + op: "Const" + input: "^decode_image/cond_jpeg/cond_png/cond_gif/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 4 + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/check_gif_channels_1" + op: "NotEqual" + input: "decode_image/cond_jpeg/cond_png/cond_gif/check_gif_channels_1/x:output:0" + input: "decode_image/cond_jpeg/cond_png/cond_gif/check_gif_channels_1/y:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/LogicalAnd" + op: "LogicalAnd" + input: "decode_image/cond_jpeg/cond_png/cond_gif/check_gif_channels:z:0" + input: "decode_image/cond_jpeg/cond_png/cond_gif/check_gif_channels_1:z:0" + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/Assert/Const" + op: "Const" + input: "^decode_image/cond_jpeg/cond_png/cond_gif/switch_t" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "Channels must be in (None, 0, 3) when decoding GIF images" + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/Assert/Assert/data_0" + op: "Const" + input: "^decode_image/cond_jpeg/cond_png/cond_gif/switch_t" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "Channels must be in (None, 0, 3) when decoding GIF images" + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/Assert/Assert" + op: "Assert" + input: "decode_image/cond_jpeg/cond_png/cond_gif/LogicalAnd:z:0" + input: "decode_image/cond_jpeg/cond_png/cond_gif/Assert/Assert/data_0:output:0" + attr { + key: "T" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "summarize" + value { + i: 3 + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/DecodeGif" + op: "DecodeGif" + input: "decode_image/cond_jpeg/cond_png/cond_gif/DecodeGif/Switch_1:output_true:0" + input: "^decode_image/cond_jpeg/cond_png/cond_gif/Assert/Assert" + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/DecodeGif/Switch" + op: "Switch" + input: "decode_image/cond_jpeg/cond_png/DecodePng/Switch:output_false:0" + input: "decode_image/cond_jpeg/cond_png/pred_id:output:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_class" + value { + list { + s: "loc:@Reshape" + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/DecodeGif/Switch_1" + op: "Switch" + input: "decode_image/cond_jpeg/cond_png/cond_gif/DecodeGif/Switch:output_false:0" + input: "decode_image/cond_jpeg/cond_png/cond_gif/pred_id:output:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_class" + value { + list { + s: "loc:@Reshape" + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/Substr/pos" + op: "Const" + input: "^decode_image/cond_jpeg/cond_png/cond_gif/switch_f" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/Substr/len" + op: "Const" + input: "^decode_image/cond_jpeg/cond_png/cond_gif/switch_f" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/Substr" + op: "Substr" + input: "decode_image/cond_jpeg/cond_png/cond_gif/Substr/Switch:output_false:0" + input: "decode_image/cond_jpeg/cond_png/cond_gif/Substr/pos:output:0" + input: "decode_image/cond_jpeg/cond_png/cond_gif/Substr/len:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/Substr/Switch" + op: "Switch" + input: "decode_image/cond_jpeg/cond_png/cond_gif/DecodeGif/Switch:output_false:0" + input: "decode_image/cond_jpeg/cond_png/cond_gif/pred_id:output:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_class" + value { + list { + s: "loc:@Reshape" + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/is_bmp/y" + op: "Const" + input: "^decode_image/cond_jpeg/cond_png/cond_gif/switch_f" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "BM" + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/is_bmp" + op: "Equal" + input: "decode_image/cond_jpeg/cond_png/cond_gif/Substr:output:0" + input: "decode_image/cond_jpeg/cond_png/cond_gif/is_bmp/y:output:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/Assert_1/Const" + op: "Const" + input: "^decode_image/cond_jpeg/cond_png/cond_gif/switch_f" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "Unable to decode bytes as JPEG, PNG, GIF, or BMP" + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/Assert_1/Assert/data_0" + op: "Const" + input: "^decode_image/cond_jpeg/cond_png/cond_gif/switch_f" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "Unable to decode bytes as JPEG, PNG, GIF, or BMP" + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/Assert_1/Assert" + op: "Assert" + input: "decode_image/cond_jpeg/cond_png/cond_gif/is_bmp:z:0" + input: "decode_image/cond_jpeg/cond_png/cond_gif/Assert_1/Assert/data_0:output:0" + attr { + key: "T" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "summarize" + value { + i: 3 + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/check_channels/x" + op: "Const" + input: "^decode_image/cond_jpeg/cond_png/cond_gif/switch_f" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/check_channels/y" + op: "Const" + input: "^decode_image/cond_jpeg/cond_png/cond_gif/switch_f" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/check_channels" + op: "NotEqual" + input: "decode_image/cond_jpeg/cond_png/cond_gif/check_channels/x:output:0" + input: "decode_image/cond_jpeg/cond_png/cond_gif/check_channels/y:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/Assert_2/Const" + op: "Const" + input: "^decode_image/cond_jpeg/cond_png/cond_gif/switch_f" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "Channels must be in (None, 0, 3) when decoding BMP images" + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/Assert_2/Assert/data_0" + op: "Const" + input: "^decode_image/cond_jpeg/cond_png/cond_gif/switch_f" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "Channels must be in (None, 0, 3) when decoding BMP images" + } + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/Assert_2/Assert" + op: "Assert" + input: "decode_image/cond_jpeg/cond_png/cond_gif/check_channels:z:0" + input: "decode_image/cond_jpeg/cond_png/cond_gif/Assert_2/Assert/data_0:output:0" + attr { + key: "T" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "summarize" + value { + i: 3 + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/DecodeBmp" + op: "DecodeBmp" + input: "decode_image/cond_jpeg/cond_png/cond_gif/Substr/Switch:output_false:0" + input: "^decode_image/cond_jpeg/cond_png/cond_gif/Assert_1/Assert" + input: "^decode_image/cond_jpeg/cond_png/cond_gif/Assert_2/Assert" + attr { + key: "channels" + value { + i: 0 + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/cond_gif/Merge" + op: "Merge" + input: "decode_image/cond_jpeg/cond_png/cond_gif/DecodeBmp:image:0" + input: "decode_image/cond_jpeg/cond_png/cond_gif/DecodeGif:image:0" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_UINT8 + } + } + } + node_def { + name: "decode_image/cond_jpeg/cond_png/Merge" + op: "Merge" + input: "decode_image/cond_jpeg/cond_png/cond_gif/Merge:output:0" + input: "decode_image/cond_jpeg/cond_png/DecodePng:image:0" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_UINT8 + } + } + } + node_def { + name: "decode_image/cond_jpeg/Merge" + op: "Merge" + input: "decode_image/cond_jpeg/cond_png/Merge:output:0" + input: "decode_image/cond_jpeg/DecodeJpeg:image:0" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_UINT8 + } + } + } + node_def { + name: "convert_image/Cast" + op: "Cast" + input: "decode_image/cond_jpeg/Merge:output:0" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_UINT8 + } + } + } + node_def { + name: "convert_image/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.00392156885937 + } + } + } + } + node_def { + name: "convert_image" + op: "Mul" + input: "convert_image/Cast:y:0" + input: "convert_image/y:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + } + node_def { + name: "Const" + op: "Const" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\200?\000\000\200?" + } + } + } + } + node_def { + name: "distorted_bounding_box_crop/Shape" + op: "Shape" + input: "convert_image:z:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } + } + node_def { + name: "distorted_bounding_box_crop/sample_distorted_bounding_box/SampleDistortedBoundingBoxV2/min_object_covered" + op: "Const" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.10000000149 + } + } + } + } + node_def { + name: "distorted_bounding_box_crop/sample_distorted_bounding_box/SampleDistortedBoundingBoxV2" + op: "SampleDistortedBoundingBoxV2" + input: "distorted_bounding_box_crop/Shape:output:0" + input: "Const:output:0" + input: "distorted_bounding_box_crop/sample_distorted_bounding_box/SampleDistortedBoundingBoxV2/min_object_covered:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "area_range" + value { + list { + f: 0.0799999982119 + f: 1.0 + } + } + } + attr { + key: "aspect_ratio_range" + value { + list { + f: 0.75 + f: 1.33333337307 + } + } + } + attr { + key: "max_attempts" + value { + i: 1 + } + } + attr { + key: "seed" + value { + i: 0 + } + } + attr { + key: "seed2" + value { + i: 0 + } + } + attr { + key: "use_image_if_no_bounding_boxes" + value { + b: true + } + } + } + node_def { + name: "distorted_bounding_box_crop/Slice" + op: "Slice" + input: "convert_image:z:0" + input: "distorted_bounding_box_crop/sample_distorted_bounding_box/SampleDistortedBoundingBoxV2:begin:0" + input: "distorted_bounding_box_crop/sample_distorted_bounding_box/SampleDistortedBoundingBoxV2:size:0" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + } + node_def { + name: "Shape" + op: "Shape" + input: "convert_image:z:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } + } + node_def { + name: "Shape_1" + op: "Shape" + input: "distorted_bounding_box_crop/Slice:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } + } + node_def { + name: "Equal" + op: "Equal" + input: "Shape:output:0" + input: "Shape_1:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + } + node_def { + name: "Cast" + op: "Cast" + input: "Equal:z:0" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + } + node_def { + name: "Const_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node_def { + name: "Sum" + op: "Sum" + input: "Cast:y:0" + input: "Const_1:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node_def { + name: "GreaterEqual/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } + } + node_def { + name: "GreaterEqual" + op: "GreaterEqual" + input: "Sum:output:0" + input: "GreaterEqual/y:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + } + node_def { + name: "cond/Switch" + op: "Switch" + input: "GreaterEqual:z:0" + input: "GreaterEqual:z:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "cond/switch_t" + op: "Identity" + input: "cond/Switch:output_true:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "cond/switch_f" + op: "Identity" + input: "cond/Switch:output_false:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "cond/pred_id" + op: "Identity" + input: "GreaterEqual:z:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "cond/Shape" + op: "Shape" + input: "cond/Shape/Switch:output_true:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } + } + node_def { + name: "cond/Shape/Switch" + op: "Switch" + input: "convert_image:z:0" + input: "cond/pred_id:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@convert_image" + } + } + } + } + node_def { + name: "cond/Cast" + op: "Cast" + input: "cond/Shape:output:0" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + } + node_def { + name: "cond/strided_slice/stack" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node_def { + name: "cond/strided_slice/stack_1" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/strided_slice/stack_2" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/strided_slice" + op: "StridedSlice" + input: "cond/Cast:y:0" + input: "cond/strided_slice/stack:output:0" + input: "cond/strided_slice/stack_1:output:0" + input: "cond/strided_slice/stack_2:output:0" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } + } + node_def { + name: "cond/strided_slice_1/stack" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/strided_slice_1/stack_1" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } + } + node_def { + name: "cond/strided_slice_1/stack_2" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/strided_slice_1" + op: "StridedSlice" + input: "cond/Cast:y:0" + input: "cond/strided_slice_1/stack:output:0" + input: "cond/strided_slice_1/stack_1:output:0" + input: "cond/strided_slice_1/stack_2:output:0" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } + } + node_def { + name: "cond/Greater" + op: "Greater" + input: "cond/strided_slice:output:0" + input: "cond/strided_slice_1:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + } + node_def { + name: "cond/cond/Switch" + op: "Switch" + input: "cond/Greater:z:0" + input: "cond/Greater:z:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "cond/cond/switch_t" + op: "Identity" + input: "cond/cond/Switch:output_true:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "cond/cond/switch_f" + op: "Identity" + input: "cond/cond/Switch:output_false:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "cond/cond/pred_id" + op: "Identity" + input: "cond/Greater:z:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "cond/cond/strided_slice/stack" + op: "Const" + input: "^cond/cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node_def { + name: "cond/cond/strided_slice/stack_1" + op: "Const" + input: "^cond/cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/cond/strided_slice/stack_2" + op: "Const" + input: "^cond/cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/cond/strided_slice" + op: "StridedSlice" + input: "cond/cond/strided_slice/Switch:output_true:0" + input: "cond/cond/strided_slice/stack:output:0" + input: "cond/cond/strided_slice/stack_1:output:0" + input: "cond/cond/strided_slice/stack_2:output:0" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } + } + node_def { + name: "cond/cond/strided_slice/Switch" + op: "Switch" + input: "cond/Cast:y:0" + input: "cond/cond/pred_id:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@cond/Cast" + } + } + } + } + node_def { + name: "cond/cond/strided_slice_1/stack" + op: "Const" + input: "^cond/cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/cond/strided_slice_1/stack_1" + op: "Const" + input: "^cond/cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } + } + node_def { + name: "cond/cond/strided_slice_1/stack_2" + op: "Const" + input: "^cond/cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/cond/strided_slice_1" + op: "StridedSlice" + input: "cond/cond/strided_slice/Switch:output_true:0" + input: "cond/cond/strided_slice_1/stack:output:0" + input: "cond/cond/strided_slice_1/stack_1:output:0" + input: "cond/cond/strided_slice_1/stack_2:output:0" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } + } + node_def { + name: "cond/cond/truediv" + op: "RealDiv" + input: "cond/cond/strided_slice:output:0" + input: "cond/cond/strided_slice_1:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + } + node_def { + name: "cond/cond/mul/y" + op: "Const" + input: "^cond/cond/switch_t" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 224.0 + } + } + } + } + node_def { + name: "cond/cond/mul" + op: "Mul" + input: "cond/cond/truediv:z:0" + input: "cond/cond/mul/y:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + } + node_def { + name: "cond/cond/Cast/x/1" + op: "Const" + input: "^cond/cond/switch_t" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 224.0 + } + } + } + } + node_def { + name: "cond/cond/Cast/x" + op: "Pack" + input: "cond/cond/mul:z:0" + input: "cond/cond/Cast/x/1:output:0" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "axis" + value { + i: 0 + } + } + } + node_def { + name: "cond/cond/Cast" + op: "Cast" + input: "cond/cond/Cast/x:output:0" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + } + node_def { + name: "cond/cond/strided_slice_2/stack" + op: "Const" + input: "^cond/cond/switch_f" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/cond/strided_slice_2/stack_1" + op: "Const" + input: "^cond/cond/switch_f" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } + } + node_def { + name: "cond/cond/strided_slice_2/stack_2" + op: "Const" + input: "^cond/cond/switch_f" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/cond/strided_slice_2" + op: "StridedSlice" + input: "cond/cond/strided_slice_2/Switch:output_false:0" + input: "cond/cond/strided_slice_2/stack:output:0" + input: "cond/cond/strided_slice_2/stack_1:output:0" + input: "cond/cond/strided_slice_2/stack_2:output:0" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } + } + node_def { + name: "cond/cond/strided_slice_2/Switch" + op: "Switch" + input: "cond/Cast:y:0" + input: "cond/cond/pred_id:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@cond/Cast" + } + } + } + } + node_def { + name: "cond/cond/strided_slice_3/stack" + op: "Const" + input: "^cond/cond/switch_f" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node_def { + name: "cond/cond/strided_slice_3/stack_1" + op: "Const" + input: "^cond/cond/switch_f" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/cond/strided_slice_3/stack_2" + op: "Const" + input: "^cond/cond/switch_f" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/cond/strided_slice_3" + op: "StridedSlice" + input: "cond/cond/strided_slice_2/Switch:output_false:0" + input: "cond/cond/strided_slice_3/stack:output:0" + input: "cond/cond/strided_slice_3/stack_1:output:0" + input: "cond/cond/strided_slice_3/stack_2:output:0" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } + } + node_def { + name: "cond/cond/truediv_1" + op: "RealDiv" + input: "cond/cond/strided_slice_2:output:0" + input: "cond/cond/strided_slice_3:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + } + node_def { + name: "cond/cond/mul_1/y" + op: "Const" + input: "^cond/cond/switch_f" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 224.0 + } + } + } + } + node_def { + name: "cond/cond/mul_1" + op: "Mul" + input: "cond/cond/truediv_1:z:0" + input: "cond/cond/mul_1/y:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + } + node_def { + name: "cond/cond/Cast_1/x/0" + op: "Const" + input: "^cond/cond/switch_f" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 224.0 + } + } + } + } + node_def { + name: "cond/cond/Cast_1/x" + op: "Pack" + input: "cond/cond/Cast_1/x/0:output:0" + input: "cond/cond/mul_1:z:0" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "axis" + value { + i: 0 + } + } + } + node_def { + name: "cond/cond/Cast_1" + op: "Cast" + input: "cond/cond/Cast_1/x:output:0" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + } + node_def { + name: "cond/cond/Merge" + op: "Merge" + input: "cond/cond/Cast_1:y:0" + input: "cond/cond/Cast:y:0" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + } + node_def { + name: "cond/ResizeBicubic/images" + op: "Pack" + input: "cond/Shape/Switch:output_true:0" + attr { + key: "N" + value { + i: 1 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "axis" + value { + i: 0 + } + } + } + node_def { + name: "cond/ResizeBicubic" + op: "ResizeBicubic" + input: "cond/ResizeBicubic/images:output:0" + input: "cond/cond/Merge:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "align_corners" + value { + b: false + } + } + } + node_def { + name: "cond/strided_slice_2/stack" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node_def { + name: "cond/strided_slice_2/stack_1" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/strided_slice_2/stack_2" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/strided_slice_2" + op: "StridedSlice" + input: "cond/ResizeBicubic:resized_images:0" + input: "cond/strided_slice_2/stack:output:0" + input: "cond/strided_slice_2/stack_1:output:0" + input: "cond/strided_slice_2/stack_2:output:0" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } + } + node_def { + name: "cond/Shape_1" + op: "Shape" + input: "cond/strided_slice_2:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } + } + node_def { + name: "cond/strided_slice_3/stack" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node_def { + name: "cond/strided_slice_3/stack_1" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/strided_slice_3/stack_2" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/strided_slice_3" + op: "StridedSlice" + input: "cond/Shape_1:output:0" + input: "cond/strided_slice_3/stack:output:0" + input: "cond/strided_slice_3/stack_1:output:0" + input: "cond/strided_slice_3/stack_2:output:0" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } + } + node_def { + name: "cond/Shape_2" + op: "Shape" + input: "cond/strided_slice_2:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } + } + node_def { + name: "cond/strided_slice_4/stack" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/strided_slice_4/stack_1" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } + } + node_def { + name: "cond/strided_slice_4/stack_2" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/strided_slice_4" + op: "StridedSlice" + input: "cond/Shape_2:output:0" + input: "cond/strided_slice_4/stack:output:0" + input: "cond/strided_slice_4/stack_1:output:0" + input: "cond/strided_slice_4/stack_2:output:0" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } + } + node_def { + name: "cond/sub/y" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 224 + } + } + } + } + node_def { + name: "cond/sub" + op: "Sub" + input: "cond/strided_slice_3:output:0" + input: "cond/sub/y:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + } + node_def { + name: "cond/add/y" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/add" + op: "Add" + input: "cond/sub:z:0" + input: "cond/add/y:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + } + node_def { + name: "cond/truediv/y" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } + } + node_def { + name: "cond/truediv/Cast" + op: "Cast" + input: "cond/add:z:0" + attr { + key: "DstT" + value { + type: DT_DOUBLE + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + } + node_def { + name: "cond/truediv/Cast_1" + op: "Cast" + input: "cond/truediv/y:output:0" + attr { + key: "DstT" + value { + type: DT_DOUBLE + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + } + node_def { + name: "cond/truediv" + op: "RealDiv" + input: "cond/truediv/Cast:y:0" + input: "cond/truediv/Cast_1:y:0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + } + node_def { + name: "cond/sub_1/y" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 224 + } + } + } + } + node_def { + name: "cond/sub_1" + op: "Sub" + input: "cond/strided_slice_4:output:0" + input: "cond/sub_1/y:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + } + node_def { + name: "cond/add_1/y" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/add_1" + op: "Add" + input: "cond/sub_1:z:0" + input: "cond/add_1/y:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + } + node_def { + name: "cond/truediv_1/y" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } + } + node_def { + name: "cond/truediv_1/Cast" + op: "Cast" + input: "cond/add_1:z:0" + attr { + key: "DstT" + value { + type: DT_DOUBLE + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + } + node_def { + name: "cond/truediv_1/Cast_1" + op: "Cast" + input: "cond/truediv_1/y:output:0" + attr { + key: "DstT" + value { + type: DT_DOUBLE + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + } + node_def { + name: "cond/truediv_1" + op: "RealDiv" + input: "cond/truediv_1/Cast:y:0" + input: "cond/truediv_1/Cast_1:y:0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + } + node_def { + name: "cond/Shape_3" + op: "Shape" + input: "cond/strided_slice_2:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } + } + node_def { + name: "cond/Rank" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } + } + node_def { + name: "cond/Equal/y" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } + } + node_def { + name: "cond/Equal" + op: "Equal" + input: "cond/Rank:output:0" + input: "cond/Equal/y:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + } + node_def { + name: "cond/Assert/Const" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "Rank of image must be equal to 3." + } + } + } + } + node_def { + name: "cond/Assert/Assert/data_0" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "Rank of image must be equal to 3." + } + } + } + } + node_def { + name: "cond/Assert/Assert" + op: "Assert" + input: "cond/Equal:z:0" + input: "cond/Assert/Assert/data_0:output:0" + attr { + key: "T" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "summarize" + value { + i: 3 + } + } + } + node_def { + name: "cond/strided_slice_5/stack" + op: "Const" + input: "^cond/Assert/Assert" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } + } + node_def { + name: "cond/strided_slice_5/stack_1" + op: "Const" + input: "^cond/Assert/Assert" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } + } + node_def { + name: "cond/strided_slice_5/stack_2" + op: "Const" + input: "^cond/Assert/Assert" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/strided_slice_5" + op: "StridedSlice" + input: "cond/Shape_3:output:0" + input: "cond/strided_slice_5/stack:output:0" + input: "cond/strided_slice_5/stack_1:output:0" + input: "cond/strided_slice_5/stack_2:output:0" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } + } + node_def { + name: "cond/stack/0" + op: "Const" + input: "^cond/Assert/Assert" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 224 + } + } + } + } + node_def { + name: "cond/stack/1" + op: "Const" + input: "^cond/Assert/Assert" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 224 + } + } + } + } + node_def { + name: "cond/stack" + op: "Pack" + input: "cond/stack/0:output:0" + input: "cond/stack/1:output:0" + input: "cond/strided_slice_5:output:0" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } + } + node_def { + name: "cond/strided_slice_6/stack" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node_def { + name: "cond/strided_slice_6/stack_1" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/strided_slice_6/stack_2" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/strided_slice_6" + op: "StridedSlice" + input: "cond/Shape_3:output:0" + input: "cond/strided_slice_6/stack:output:0" + input: "cond/strided_slice_6/stack_1:output:0" + input: "cond/strided_slice_6/stack_2:output:0" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } + } + node_def { + name: "cond/GreaterEqual/y" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 224 + } + } + } + } + node_def { + name: "cond/GreaterEqual" + op: "GreaterEqual" + input: "cond/strided_slice_6:output:0" + input: "cond/GreaterEqual/y:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + } + node_def { + name: "cond/strided_slice_7/stack" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/strided_slice_7/stack_1" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } + } + node_def { + name: "cond/strided_slice_7/stack_2" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/strided_slice_7" + op: "StridedSlice" + input: "cond/Shape_3:output:0" + input: "cond/strided_slice_7/stack:output:0" + input: "cond/strided_slice_7/stack_1:output:0" + input: "cond/strided_slice_7/stack_2:output:0" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } + } + node_def { + name: "cond/GreaterEqual_1/y" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 224 + } + } + } + } + node_def { + name: "cond/GreaterEqual_1" + op: "GreaterEqual" + input: "cond/strided_slice_7:output:0" + input: "cond/GreaterEqual_1/y:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + } + node_def { + name: "cond/LogicalAnd" + op: "LogicalAnd" + input: "cond/GreaterEqual:z:0" + input: "cond/GreaterEqual_1:z:0" + } + node_def { + name: "cond/Assert_1/Const" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "Crop size greater than the image size." + } + } + } + } + node_def { + name: "cond/Assert_1/Assert/data_0" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "Crop size greater than the image size." + } + } + } + } + node_def { + name: "cond/Assert_1/Assert" + op: "Assert" + input: "cond/LogicalAnd:z:0" + input: "cond/Assert_1/Assert/data_0:output:0" + attr { + key: "T" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "summarize" + value { + i: 3 + } + } + } + node_def { + name: "cond/stack_1/2" + op: "Const" + input: "^cond/switch_t" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 0.0 + } + } + } + } + node_def { + name: "cond/stack_1" + op: "Pack" + input: "cond/truediv:z:0" + input: "cond/truediv_1:z:0" + input: "cond/stack_1/2:output:0" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "axis" + value { + i: 0 + } + } + } + node_def { + name: "cond/ToInt32" + op: "Cast" + input: "cond/stack_1:output:0" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_DOUBLE + } + } + } + node_def { + name: "cond/Slice" + op: "Slice" + input: "cond/strided_slice_2:output:0" + input: "cond/ToInt32:y:0" + input: "cond/stack:output:0" + input: "^cond/Assert_1/Assert" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + } + node_def { + name: "cond/Reshape" + op: "Reshape" + input: "cond/Slice:output:0" + input: "cond/stack:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + } + node_def { + name: "cond/ResizeBicubic_1/images" + op: "Pack" + input: "cond/ResizeBicubic_1/images/Switch:output_false:0" + attr { + key: "N" + value { + i: 1 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "axis" + value { + i: 0 + } + } + } + node_def { + name: "cond/ResizeBicubic_1/images/Switch" + op: "Switch" + input: "distorted_bounding_box_crop/Slice:output:0" + input: "cond/pred_id:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@distorted_bounding_box_crop/Slice" + } + } + } + } + node_def { + name: "cond/ResizeBicubic_1/size" + op: "Const" + input: "^cond/switch_f" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\340\000\000\000\340\000\000\000" + } + } + } + } + node_def { + name: "cond/ResizeBicubic_1" + op: "ResizeBicubic" + input: "cond/ResizeBicubic_1/images:output:0" + input: "cond/ResizeBicubic_1/size:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "align_corners" + value { + b: false + } + } + } + node_def { + name: "cond/strided_slice_8/stack" + op: "Const" + input: "^cond/switch_f" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node_def { + name: "cond/strided_slice_8/stack_1" + op: "Const" + input: "^cond/switch_f" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/strided_slice_8/stack_2" + op: "Const" + input: "^cond/switch_f" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "cond/strided_slice_8" + op: "StridedSlice" + input: "cond/ResizeBicubic_1:resized_images:0" + input: "cond/strided_slice_8/stack:output:0" + input: "cond/strided_slice_8/stack_1:output:0" + input: "cond/strided_slice_8/stack_2:output:0" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } + } + node_def { + name: "cond/Merge" + op: "Merge" + input: "cond/strided_slice_8:output:0" + input: "cond/Reshape:output:0" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + } + node_def { + name: "Const_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + tensor_content: "\354Q\370>\325x\351>;\337\317>" + } + } + } + } + node_def { + name: "sub" + op: "Sub" + input: "cond/Merge:output:0" + input: "Const_2:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + } + node_def { + name: "Const_3" + op: "Const" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + tensor_content: "\372~j>B`e>fff>" + } + } + } + } + node_def { + name: "truediv" + op: "RealDiv" + input: "sub:z:0" + input: "Const_3:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + } + node_def { + name: "random_flip_left_right/control_dependency" + op: "Identity" + input: "truediv:z:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@truediv" + } + } + } + } + node_def { + name: "random_flip_left_right/random_uniform/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } + } + node_def { + name: "random_flip_left_right/random_uniform/min" + op: "Const" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } + } + node_def { + name: "random_flip_left_right/random_uniform/max" + op: "Const" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } + } + node_def { + name: "random_flip_left_right/random_uniform/RandomUniform" + op: "RandomUniform" + input: "random_flip_left_right/random_uniform/shape:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 0 + } + } + attr { + key: "seed2" + value { + i: 0 + } + } + } + node_def { + name: "random_flip_left_right/random_uniform/sub" + op: "Sub" + input: "random_flip_left_right/random_uniform/max:output:0" + input: "random_flip_left_right/random_uniform/min:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + } + node_def { + name: "random_flip_left_right/random_uniform/mul" + op: "Mul" + input: "random_flip_left_right/random_uniform/RandomUniform:output:0" + input: "random_flip_left_right/random_uniform/sub:z:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + } + node_def { + name: "random_flip_left_right/random_uniform" + op: "Add" + input: "random_flip_left_right/random_uniform/mul:z:0" + input: "random_flip_left_right/random_uniform/min:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + } + node_def { + name: "random_flip_left_right/Less/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } + } + node_def { + name: "random_flip_left_right/Less" + op: "Less" + input: "random_flip_left_right/random_uniform:z:0" + input: "random_flip_left_right/Less/y:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + } + node_def { + name: "random_flip_left_right/Switch" + op: "Switch" + input: "random_flip_left_right/Less:z:0" + input: "random_flip_left_right/Less:z:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "random_flip_left_right/switch_t" + op: "Identity" + input: "random_flip_left_right/Switch:output_true:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "random_flip_left_right/switch_f" + op: "Identity" + input: "random_flip_left_right/Switch:output_false:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "random_flip_left_right/pred_id" + op: "Identity" + input: "random_flip_left_right/Less:z:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + } + node_def { + name: "random_flip_left_right/ReverseV2/axis" + op: "Const" + input: "^random_flip_left_right/switch_t" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "random_flip_left_right/ReverseV2" + op: "ReverseV2" + input: "random_flip_left_right/ReverseV2/Switch:output_true:0" + input: "random_flip_left_right/ReverseV2/axis:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + } + node_def { + name: "random_flip_left_right/ReverseV2/Switch" + op: "Switch" + input: "random_flip_left_right/control_dependency:output:0" + input: "random_flip_left_right/pred_id:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@truediv" + } + } + } + } + node_def { + name: "random_flip_left_right/Switch_1" + op: "Switch" + input: "random_flip_left_right/control_dependency:output:0" + input: "random_flip_left_right/pred_id:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@truediv" + } + } + } + } + node_def { + name: "random_flip_left_right/Merge" + op: "Merge" + input: "random_flip_left_right/Switch_1:output_false:0" + input: "random_flip_left_right/ReverseV2:output:0" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + } + node_def { + name: "Reshape_1/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\340\000\000\000\340\000\000\000\003\000\000\000" + } + } + } + } + node_def { + name: "Reshape_1" + op: "Reshape" + input: "random_flip_left_right/Merge:output:0" + input: "Reshape_1/shape:output:0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + } + node_def { + name: "Reshape_2/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } + } + node_def { + name: "Reshape_2" + op: "Reshape" + input: "ParseSingleExample/ParseSingleExample:dense_values:0" + input: "Reshape_2/shape:output:0" + attr { + key: "T" + value { + type: DT_INT64 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + } + node_def { + name: "Cast_1" + op: "Cast" + input: "Reshape_2:output:0" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_INT64 + } + } + } + node_def { + name: "sub_1/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node_def { + name: "sub_1" + op: "Sub" + input: "Cast_1:y:0" + input: "sub_1/y:output:0" + attr { + key: "T" + value { + type: DT_INT32 + } + } + } + ret { + key: "Reshape_1" + value: "Reshape_1:output:0" + } + ret { + key: "sub_1" + value: "sub_1:z:0" + } + } + function { + signature { + name: "tf_predicate_7089b845" + input_arg { + name: "arg0" + type: DT_FLOAT + } + input_arg { + name: "arg1" + type: DT_INT32 + } + input_arg { + name: "Equal/Placeholder" + type: DT_INT64 + } + output_arg { + name: "Equal" + type: DT_BOOL + } + description: "A wrapper for Defun that facilitates shape inference." + } + node_def { + name: "Shape" + op: "Shape" + input: "arg0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "out_type" + value { + type: DT_INT64 + } + } + } + node_def { + name: "strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node_def { + name: "strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "strided_slice" + op: "StridedSlice" + input: "Shape:output:0" + input: "strided_slice/stack:output:0" + input: "strided_slice/stack_1:output:0" + input: "strided_slice/stack_2:output:0" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT64 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } + } + node_def { + name: "Equal" + op: "Equal" + input: "strided_slice:output:0" + input: "Equal/Placeholder" + attr { + key: "T" + value { + type: DT_INT64 + } + } + } + ret { + key: "Equal" + value: "Equal:z:0" + } + } + function { + signature { + name: "_make_dataset_5fa5e1f4" + output_arg { + name: "PrefetchDataset_1" + type: DT_VARIANT + } + is_stateful: true + } + node_def { + name: "TensorSliceDataset/MatchingFiles/pattern" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "$(DATA_DIR)" + } + } + } + } + node_def { + name: "TensorSliceDataset/MatchingFiles" + op: "MatchingFiles" + input: "TensorSliceDataset/MatchingFiles/pattern:output:0" + } + node_def { + name: "TensorSliceDataset" + op: "TensorSliceDataset" + input: "TensorSliceDataset/MatchingFiles:filenames:0" + attr { + key: "Toutput_types" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "output_shapes" + value { + list { + shape { + } + } + } + } + } + node_def { + name: "ShuffleDataset/MatchingFiles/pattern" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "$(DATA_DIR)" + } + } + } + } + node_def { + name: "ShuffleDataset/MatchingFiles" + op: "MatchingFiles" + input: "ShuffleDataset/MatchingFiles/pattern:output:0" + } + node_def { + name: "ShuffleDataset/Shape" + op: "Shape" + input: "ShuffleDataset/MatchingFiles:filenames:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "out_type" + value { + type: DT_INT64 + } + } + } + node_def { + name: "ShuffleDataset/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node_def { + name: "ShuffleDataset/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "ShuffleDataset/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } + } + node_def { + name: "ShuffleDataset/strided_slice" + op: "StridedSlice" + input: "ShuffleDataset/Shape:output:0" + input: "ShuffleDataset/strided_slice/stack:output:0" + input: "ShuffleDataset/strided_slice/stack_1:output:0" + input: "ShuffleDataset/strided_slice/stack_2:output:0" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT64 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } + } + node_def { + name: "ShuffleDataset/Maximum/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 1 + } + } + } + } + node_def { + name: "ShuffleDataset/Maximum" + op: "Maximum" + input: "ShuffleDataset/strided_slice:output:0" + input: "ShuffleDataset/Maximum/y:output:0" + attr { + key: "T" + value { + type: DT_INT64 + } + } + } + node_def { + name: "ShuffleDataset/seed" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 0 + } + } + } + } + node_def { + name: "ShuffleDataset/seed2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 0 + } + } + } + } + node_def { + name: "ShuffleDataset" + op: "ShuffleDataset" + input: "TensorSliceDataset:handle:0" + input: "ShuffleDataset/Maximum:z:0" + input: "ShuffleDataset/seed:output:0" + input: "ShuffleDataset/seed2:output:0" + attr { + key: "output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "output_types" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "reshuffle_each_iteration" + value { + b: true + } + } + } + node_def { + name: "ShuffleDataset_1/buffer_size" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 1024 + } + } + } + } + node_def { + name: "ShuffleDataset_1/seed_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 0 + } + } + } + } + node_def { + name: "ShuffleDataset_1/seed2_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 0 + } + } + } + } + node_def { + name: "ShuffleDataset_1" + op: "ShuffleDataset" + input: "ShuffleDataset:handle:0" + input: "ShuffleDataset_1/buffer_size:output:0" + input: "ShuffleDataset_1/seed_1:output:0" + input: "ShuffleDataset_1/seed2_1:output:0" + attr { + key: "output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "output_types" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "reshuffle_each_iteration" + value { + b: true + } + } + } + node_def { + name: "RepeatDataset/count" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: -1 + } + } + } + } + node_def { + name: "RepeatDataset" + op: "RepeatDataset" + input: "ShuffleDataset_1:handle:0" + input: "RepeatDataset/count:output:0" + attr { + key: "output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "output_types" + value { + list { + type: DT_STRING + } + } + } + } + node_def { + name: "ParallelInterleaveDataset/cycle_length" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 8 + } + } + } + } + node_def { + name: "ParallelInterleaveDataset/block_length" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 1 + } + } + } + } + node_def { + name: "ParallelInterleaveDataset/sloppy" + op: "Const" + attr { + key: "dtype" + value { + type: DT_BOOL + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_BOOL + tensor_shape { + } + bool_val: true + } + } + } + } + node_def { + name: "ParallelInterleaveDataset/buffer_output_elements" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 2 + } + } + } + } + node_def { + name: "ParallelInterleaveDataset/prefetch_input_elements" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 16 + } + } + } + } + node_def { + name: "ParallelInterleaveDataset" + op: "ParallelInterleaveDataset" + input: "RepeatDataset:handle:0" + input: "ParallelInterleaveDataset/cycle_length:output:0" + input: "ParallelInterleaveDataset/block_length:output:0" + input: "ParallelInterleaveDataset/sloppy:output:0" + input: "ParallelInterleaveDataset/buffer_output_elements:output:0" + input: "ParallelInterleaveDataset/prefetch_input_elements:output:0" + attr { + key: "Targuments" + value { + list { + } + } + } + attr { + key: "f" + value { + func { + name: "tf_map_func_91295dea" + } + } + } + attr { + key: "output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "output_types" + value { + list { + type: DT_STRING + } + } + } + } + node_def { + name: "ShuffleDataset_2/buffer_size_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 1024 + } + } + } + } + node_def { + name: "ShuffleDataset_2/seed_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 0 + } + } + } + } + node_def { + name: "ShuffleDataset_2/seed2_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 0 + } + } + } + } + node_def { + name: "ShuffleDataset_2" + op: "ShuffleDataset" + input: "ParallelInterleaveDataset:handle:0" + input: "ShuffleDataset_2/buffer_size_1:output:0" + input: "ShuffleDataset_2/seed_2:output:0" + input: "ShuffleDataset_2/seed2_2:output:0" + attr { + key: "output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "output_types" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "reshuffle_each_iteration" + value { + b: true + } + } + } + node_def { + name: "ParallelMapDataset/num_parallel_calls" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 64 + } + } + } + } + node_def { + name: "ParallelMapDataset" + op: "ParallelMapDataset" + input: "ShuffleDataset_2:handle:0" + input: "ParallelMapDataset/num_parallel_calls:output:0" + attr { + key: "Targuments" + value { + list { + } + } + } + attr { + key: "f" + value { + func { + name: "tf_map_func_74b6b15c" + } + } + } + attr { + key: "output_shapes" + value { + list { + shape { + dim { + size: 224 + } + dim { + size: 224 + } + dim { + size: 3 + } + } + shape { + } + } + } + } + attr { + key: "output_types" + value { + list { + type: DT_FLOAT + type: DT_INT32 + } + } + } + } + node_def { + name: "PrefetchDataset/buffer_size_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 64 + } + } + } + } + node_def { + name: "PrefetchDataset" + op: "PrefetchDataset" + input: "ParallelMapDataset:handle:0" + input: "PrefetchDataset/buffer_size_2:output:0" + attr { + key: "output_shapes" + value { + list { + shape { + dim { + size: 224 + } + dim { + size: 224 + } + dim { + size: 3 + } + } + shape { + } + } + } + } + attr { + key: "output_types" + value { + list { + type: DT_FLOAT + type: DT_INT32 + } + } + } + } + node_def { + name: "BatchDataset/batch_size" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 64 + } + } + } + } + node_def { + name: "BatchDataset" + op: "BatchDataset" + input: "PrefetchDataset:handle:0" + input: "BatchDataset/batch_size:output:0" + attr { + key: "output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 224 + } + dim { + size: 224 + } + dim { + size: 3 + } + } + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "output_types" + value { + list { + type: DT_FLOAT + type: DT_INT32 + } + } + } + } + node_def { + name: "FilterDataset/batch_size_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 64 + } + } + } + } + node_def { + name: "FilterDataset" + op: "FilterDataset" + input: "BatchDataset:handle:0" + input: "FilterDataset/batch_size_1:output:0" + attr { + key: "Targuments" + value { + list { + type: DT_INT64 + } + } + } + attr { + key: "output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 224 + } + dim { + size: 224 + } + dim { + size: 3 + } + } + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "output_types" + value { + list { + type: DT_FLOAT + type: DT_INT32 + } + } + } + attr { + key: "predicate" + value { + func { + name: "tf_predicate_7089b845" + } + } + } + } + node_def { + name: "PrefetchDataset_1/buffer_size_3" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 2 + } + } + } + } + node_def { + name: "PrefetchDataset_1" + op: "PrefetchDataset" + input: "FilterDataset:handle:0" + input: "PrefetchDataset_1/buffer_size_3:output:0" + attr { + key: "output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 224 + } + dim { + size: 224 + } + dim { + size: 3 + } + } + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "output_types" + value { + list { + type: DT_FLOAT + type: DT_INT32 + } + } + } + } + ret { + key: "PrefetchDataset_1" + value: "PrefetchDataset_1:handle:0" + } + } +} +)PREFIX"; + + *dataset_name = "_make_dataset_5fa5e1f4"; + std::function mutate_proto_func = + [dataset_name, file_path](FunctionDef* fdef) { + VLOG(1) << "Processsing function " << fdef->DebugString(); + if (std::string(fdef->signature().name()) != *dataset_name) return; + // Change the input file pattern to `file_path`. + bool found = false; + for (auto& node_def : *fdef->mutable_node_def()) { + if (node_def.name() != "TensorSliceDataset/MatchingFiles/pattern" && + node_def.name() != "ShuffleDataset/MatchingFiles/pattern") + continue; + DCHECK_EQ(node_def.op(), "Const"); + DCHECK_GT(node_def.attr().count("value"), 0); + found = true; + DCHECK_EQ(node_def.attr().at("value").tensor().string_val(0), + "$(DATA_DIR)"); + VLOG(1) << "Setting the value of node_def " + "TensorSliceDataset/MatchingFiles/pattern to " + << file_path; + auto* tensor = (*node_def.mutable_attr())["value"].mutable_tensor(); + tensor->clear_string_val(); + tensor->add_string_val(file_path); + } + VLOG(1) << "Rewrote function to " << fdef->DebugString(); + DCHECK(found); + }; + return CreateFunctionsFromTextProto(func_def, &mutate_proto_func, status); +} + +// Adds the input functions to `graph`. On success, returns the created +// IteratorGetNext node. +static TF_Operation* AddDatasetFunctionAndIteratorNodesToGraph( + const std::vector& funcs, const std::string& dataset_name, + const std::vector& output_types, + const std::vector& output_shapes, + TF_Graph* graph, TF_Status* status) { + DCHECK(!dataset_name.empty()); + for (auto& func : funcs) { + TF_GraphCopyFunction(graph, func.get(), /*gradient*/ nullptr, status); + if (!status->status.ok()) { + return nullptr; + } + } + + tensorflow::mutex_lock c(graph->mu); + + tensorflow::NameAttrList func; + func.set_name(dataset_name); + // Run the iterator node on CPU. + Node* oneshot_iterator_node; + tensorflow::Status s = NodeBuilder("OneShotIterator", "OneShotIterator") + .Device("/device:CPU:0") + .Attr("container", "") + .Attr("dataset_factory", func) + .Attr("output_types", output_types) + .Attr("output_shapes", output_shapes) + .Attr("shared_name", "") + .Finalize(&graph->graph, &oneshot_iterator_node); + if (!s.ok()) { + status->status = s; + return nullptr; + } + // Run shape inference function for each newly added node, so that more + // subsequent nodes can be added to the graph via C API (TF_NewOperation()). + s = graph->refiner.AddNode(oneshot_iterator_node); + if (!s.ok()) { + status->status = s; + return nullptr; + } + + // Run the iterator node on CPU. + Node* getnext_node; + s = NodeBuilder("IteratorGetNext", "IteratorGetNext") + .Input(oneshot_iterator_node) + .Device("/device:CPU:0") + .Attr("output_types", output_types) + .Attr("output_shapes", output_shapes) + .Finalize(&graph->graph, &getnext_node); + if (!s.ok()) { + status->status = s; + return nullptr; + } + // Run shape inference function for each newly added node, so that more + // subsequent nodes can be added to the graph via C API (TF_NewOperation()). + s = graph->refiner.AddNode(getnext_node); + if (!s.ok()) { + status->status = s; + return nullptr; + } + + VLOG(1) << "Output graph: " << graph->graph.ToGraphDefDebug().DebugString(); + return ToTF_Operation(getnext_node); +} + +TF_Operation* TF_MakeFakeIteratorGetNextWithDatasets(TF_Graph* graph, + TF_Status* status) { + tensorflow::Status s; + + std::string dataset_name; + UniqueFuncPtr result_func = CreateFakeDatasetFunction(&dataset_name, status); + if (!status->status.ok()) { + return nullptr; + } + + std::vector funcs; + funcs.push_back(std::move(result_func)); + std::vector output_shape_list; + output_shape_list.push_back(tensorflow::TensorShapeProto()); + auto* getnext_node = AddDatasetFunctionAndIteratorNodesToGraph( + funcs, dataset_name, {tensorflow::DT_FLOAT}, output_shape_list, graph, + status); + if (!status->status.ok()) { + return nullptr; + } + + return getnext_node; +} + +TF_Operation* TF_MakeImagenetIteratorGetNextWithDatasets(TF_Graph* graph, + const char* file_path, + int batch_size, + TF_Status* status) { + tensorflow::Status s; + + std::string dataset_name; + const auto& funcs = + CreateImagenetDatasetFunctions(file_path, &dataset_name, status); + if (!status->status.ok()) { + return nullptr; + } + + std::vector output_shape_list; + // batch_size X 224 X 224 X 3 + auto image_shape = tensorflow::TensorShapeProto(); + image_shape.add_dim()->set_size(batch_size); + image_shape.add_dim()->set_size(224); + image_shape.add_dim()->set_size(224); + image_shape.add_dim()->set_size(3); + output_shape_list.push_back(image_shape); + + // batch_size + auto label_shape = tensorflow::TensorShapeProto(); + label_shape.add_dim()->set_size(batch_size); + output_shape_list.push_back(label_shape); + auto* getnext_node = AddDatasetFunctionAndIteratorNodesToGraph( + funcs, dataset_name, {tensorflow::DT_FLOAT, tensorflow::DT_INT32}, + output_shape_list, graph, status); + if (!status->status.ok()) { + return nullptr; + } + + tensorflow::mutex_lock c(graph->mu); + VLOG(1) << "The extended graph: " + << graph->graph.ToGraphDefDebug().DebugString(); - VLOG(1) << "Output graph: " << graph->graph.ToGraphDefDebug().DebugString(); - *dataset_func = result_func.release(); - return ToTF_Operation(getnext_node); -} - -void TF_GetAttrScalarTensorShapeProto(TF_Buffer* value, TF_Status* status) { - status->status = Status::OK(); - auto shape = tensorflow::TensorShape({}); - tensorflow::TensorShapeProto shape_proto; - shape.AsProto(&shape_proto); - status->status = MessageToBuffer(shape_proto, value); + return getnext_node; } diff --git a/tensorflow/c/c_api_experimental.h b/tensorflow/c/c_api_experimental.h index 2fa2328..a9c551d 100644 --- a/tensorflow/c/c_api_experimental.h +++ b/tensorflow/c/c_api_experimental.h @@ -87,25 +87,22 @@ TF_CAPI_EXPORT extern const char* TF_GraphDebugString(TF_Graph* graph, TF_CAPI_EXPORT extern const char* TF_GraphDebugString(TF_Graph* graph, size_t* len); -// Creates a stack of data set + iterator nodes reading the TFRecord files from -// `file_path`, and outputs the following info on success: +// Creates a stack of data set + iterator nodes, currently hard-coded to return +// a sequence of 3 float values <42.0, 43.0, 44.0> over 3 calls. On success, +// returns the IteratorGetNext node, which caller can run or feed into an node. // -// 1. Returns the IteratorGetNext node, which caller can run or feed into an -// node. -// -// 2. Sets `dataset_func` to the created function that encapsulates the data set -// nodes. Caller owns that function, and must call TF_DeleteFunction() on it. -// -// -// The nodes are currently hard-coded to return a single Int32 of value 1. // TODO(hongm): Extend the API to allow customization of the nodes created. -TF_CAPI_EXPORT extern TF_Operation* TF_MakeIteratorGetNextWithDatasets( - TF_Graph* graph, const char* file_path, TF_Function** dataset_func, - TF_Status* status); - -// Returns the shape proto of shape {}. -TF_CAPI_EXPORT extern void TF_GetAttrScalarTensorShapeProto(TF_Buffer* value, - TF_Status* status); +TF_CAPI_EXPORT extern TF_Operation* TF_MakeFakeIteratorGetNextWithDatasets( + TF_Graph* graph, TF_Status* status); + +// Similar to the above API, except that the returned iterator reads the +// TFRecord files from `file_path`. +// The iterators outputs 2 tensors: +// - A float tensor of shape `batch_size` X 224 X 224 X 3 +// - An int32 tensor of shape `batch_size` +// TODO(hongm): Extend the API to allow customization of the nodes created. +TF_CAPI_EXPORT extern TF_Operation* TF_MakeImagenetIteratorGetNextWithDatasets( + TF_Graph* graph, const char* file_path, int batch_size, TF_Status* status); #ifdef __cplusplus } /* end extern "C" */ diff --git a/tensorflow/c/c_api_experimental_test.cc b/tensorflow/c/c_api_experimental_test.cc index 9ddd65f..49d64d1 100644 --- a/tensorflow/c/c_api_experimental_test.cc +++ b/tensorflow/c/c_api_experimental_test.cc @@ -15,38 +15,36 @@ limitations under the License. #include "tensorflow/c/c_api_experimental.h" #include "tensorflow/c/c_test_util.h" +#include "tensorflow/core/lib/io/path.h" +#include "tensorflow/core/platform/logging.h" +#include "tensorflow/core/platform/test.h" namespace tensorflow { namespace { -void TestIteratorStack() { +void TestFakeIteratorStack() { TF_Status* s = TF_NewStatus(); TF_Graph* graph = TF_NewGraph(); - TF_Function* dataset_func = nullptr; - - TF_Operation* get_next = - TF_MakeIteratorGetNextWithDatasets(graph, "dummy_path", &dataset_func, s); + TF_Operation* get_next = TF_MakeFakeIteratorGetNextWithDatasets(graph, s); ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s); - ASSERT_NE(dataset_func, nullptr); - TF_DeleteFunction(dataset_func); - CSession csession(graph, s); ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s); // Run the graph. - for (int i = 0; i < 1; ++i) { + const float base_value = 42.0; + for (int i = 0; i < 3; ++i) { csession.SetOutputs({get_next}); csession.Run(s); ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s); TF_Tensor* out = csession.output_tensor(0); ASSERT_TRUE(out != nullptr); - EXPECT_EQ(TF_INT32, TF_TensorType(out)); - EXPECT_EQ(0, TF_NumDims(out)); // scalar - ASSERT_EQ(sizeof(int32), TF_TensorByteSize(out)); - int32* output_contents = static_cast(TF_TensorData(out)); - EXPECT_EQ(1, *output_contents); + ASSERT_EQ(TF_FLOAT, TF_TensorType(out)); + ASSERT_EQ(0, TF_NumDims(out)); // scalar + ASSERT_EQ(sizeof(float), TF_TensorByteSize(out)); + float* output_contents = static_cast(TF_TensorData(out)); + ASSERT_EQ(base_value + i, *output_contents); } // This should error out since we've exhausted the iterator. @@ -60,7 +58,63 @@ void TestIteratorStack() { TF_DeleteStatus(s); } -TEST(CAPI_EXPERIMENTAL, IteratorGetNext) { TestIteratorStack(); } +TEST(CAPI_EXPERIMENTAL, FakeIteratorGetNext) { TestFakeIteratorStack(); } + +TEST(CAPI_EXPERIMENTAL, ImagenetIteratorGetNext) { + TF_Status* s = TF_NewStatus(); + TF_Graph* graph = TF_NewGraph(); + + const string file_path = tensorflow::io::JoinPath( + tensorflow::testing::TensorFlowSrcRoot(), "c/testdata/tf_record"); + VLOG(1) << "data file path is " << file_path; + const int batch_size = 64; + TF_Operation* get_next = TF_MakeImagenetIteratorGetNextWithDatasets( + graph, file_path.c_str(), batch_size, s); + ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s); + + CSession csession(graph, s); + ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s); + + // Run the graph. + // The two output tensors should look like: + // Tensor("IteratorGetNext:0", shape=(batch_size, 224, 224, 3), dtype=float32) + // Tensor("IteratorGetNext:1", shape=(batch_size, ), dtype=int32) + for (int i = 0; i < 3; ++i) { + LOG(INFO) << "Running iter " << i; + csession.SetOutputs({{get_next, 0}, {get_next, 1}}); + csession.Run(s); + ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s); + + { + TF_Tensor* image = csession.output_tensor(0); + ASSERT_TRUE(image != nullptr); + ASSERT_EQ(TF_FLOAT, TF_TensorType(image)); + // Confirm shape is 224 X 224 X 3 + ASSERT_EQ(4, TF_NumDims(image)); + ASSERT_EQ(batch_size, TF_Dim(image, 0)); + ASSERT_EQ(224, TF_Dim(image, 1)); + ASSERT_EQ(224, TF_Dim(image, 2)); + ASSERT_EQ(3, TF_Dim(image, 3)); + ASSERT_EQ(sizeof(float) * batch_size * 224 * 224 * 3, + TF_TensorByteSize(image)); + } + + { + TF_Tensor* label = csession.output_tensor(1); + ASSERT_TRUE(label != nullptr); + ASSERT_EQ(TF_INT32, TF_TensorType(label)); + ASSERT_EQ(1, TF_NumDims(label)); + ASSERT_EQ(batch_size, TF_Dim(label, 0)); + ASSERT_EQ(sizeof(int32) * batch_size, TF_TensorByteSize(label)); + } + } + + // Clean up + csession.CloseAndDelete(s); + ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s); + TF_DeleteGraph(graph); + TF_DeleteStatus(s); +} } // namespace } // namespace tensorflow diff --git a/tensorflow/c/testdata/tf_record b/tensorflow/c/testdata/tf_record new file mode 100644 index 0000000000000000000000000000000000000000..6e16076bfb79ad8151952e96567565e8820b0f5b GIT binary patch literal 417114 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�{5-nWKWhM3A03ceAlAY?>88r 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 =%?~D8raY_(3!<0`t2ZIdDXR33} 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

(R!4zftRnDf8rnkGxMe(yok*pD_}oD>G0u#a`B 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

Ine^tELE(mA3*;?uD_658nkP@KDE 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�CDaS5|9Bx=#p-1Hw1^arJbrGP6xGES-7QRamW*8 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

Akk^ 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