diff options
| author | Lester Solbakken <lesters@oath.com> | 2019-11-22 13:27:17 +0100 |
|---|---|---|
| committer | Lester Solbakken <lesters@oath.com> | 2019-11-22 13:27:17 +0100 |
| commit | 45cea0a2639c8f063079a056eec7706486418c35 (patch) | |
| tree | fa8213362f53a6ac426c7dfe085173f1c52dc24c /model-integration | |
| parent | 742c9bf3accf86ba993243e3e42961ed0923edc6 (diff) | |
Add test for tf2onnx conversion and evaluation
Diffstat (limited to 'model-integration')
18 files changed, 23990 insertions, 0 deletions
diff --git a/model-integration/src/test/java/ai/vespa/rankingexpression/importer/onnx/Tf2OnnxImportTestCase.java b/model-integration/src/test/java/ai/vespa/rankingexpression/importer/onnx/Tf2OnnxImportTestCase.java new file mode 100644 index 00000000000..cd5cee0f6bc --- /dev/null +++ b/model-integration/src/test/java/ai/vespa/rankingexpression/importer/onnx/Tf2OnnxImportTestCase.java @@ -0,0 +1,153 @@ +// Copyright 2018 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +package ai.vespa.rankingexpression.importer.onnx; + +import ai.vespa.rankingexpression.importer.ImportedModel; +import ai.vespa.rankingexpression.importer.tensorflow.TensorFlowImporter; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ArrayNode; +import com.fasterxml.jackson.databind.node.ObjectNode; +import com.yahoo.collections.Pair; +import com.yahoo.system.ProcessExecuter; +import com.yahoo.tensor.Tensor; +import org.junit.Ignore; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; +import org.tensorflow.SavedModelBundle; + +import java.io.IOException; +import java.nio.file.Paths; +import java.util.HashMap; +import java.util.Map; + +/** + * Tries to convert a set of TensorFlow models to ONNX using the tf2onnx tool, + * and asserts that the result when evaluated on TensorFlow, the imported + * TensorFlow model and the imported ONNX model are equal. + * + * Requires the tf2onnx tool to be installed so the test itself should be ignored. + * + * @author lesters + */ +public class Tf2OnnxImportTestCase extends TestableModel { + + @Rule + public TemporaryFolder testFolder = new TemporaryFolder(); + + @Test + @Ignore + public void testOnnxConversionAndImport() { + Report report = new Report(); + for (int i = 11; i < 12; ++i) { + testModelsWithOpset(report, i); + } + System.out.println(report); + } + + private void testModelsWithOpset(Report report, int opset) { + String [] models = { + "tensorflow/mnist/saved/", + "tensorflow/mnist_softmax/saved/", + "tensorflow/9662/", + "tensorflow/regression/test1/", + "tensorflow/regression/test2/", + "tensorflow/softmax/saved/", + "tensorflow/blog/saved/", + "tensorflow/batch_norm/saved/", + "tensorflow/dropout/saved/", + "tensorflow/external/Model_A/optimized_v2/", + "tensorflow/external/Model_B/factorization_machine_v1/export/optimized/", + "tensorflow/external/Model_B/factorization_machine_v1/export/standard/", + "tensorflow/external/Model_C/factorization_machine_v1/export/optimized/", + "tensorflow/external/Model_C/factorization_machine_v1/export/standard/", + "tensorflow/external/modelv1/", + "tensorflow/external/modelv2/" + }; + for (String model : models) { + try { + testModelWithOpset(report, opset, "src/test/models/" + model); + } catch (Exception e) { + report.add(model, opset, false, "Exception: " + e.getMessage()); + } + } + } + + private boolean testModelWithOpset(Report report, int opset, String tfModel) throws IOException { + String onnxModel = Paths.get(testFolder.getRoot().getAbsolutePath(), "converted.onnx").toString(); + + var res = tf2onnxConvert(tfModel, onnxModel, opset); + if (res.getFirst() != 0) { + return reportAndFail(report, opset, tfModel, "tf2onnx conversion failed: " + res.getSecond()); + } + + SavedModelBundle tensorFlowModel = SavedModelBundle.load(tfModel, "serve"); + ImportedModel model = new TensorFlowImporter().importModel("test", tfModel, tensorFlowModel); + ImportedModel onnxImportedModel = new OnnxImporter().importModel("test", onnxModel); + + if (model.signature("serving_default").skippedOutputs().size() > 0) { + return reportAndFail(report, opset, tfModel, "Failed to import model from TensorFlow due to skipped outputs"); + } + if (onnxImportedModel.signature("default").skippedOutputs().size() > 0) { + return reportAndFail(report, opset, tfModel, "Failed to import model from ONNX due to skipped outputs"); + } + + ImportedModel.Signature sig = model.signatures().values().iterator().next(); + String output = sig.outputs().values().iterator().next(); + String onnxOutput = onnxImportedModel.signatures().values().iterator().next().outputs().values().iterator().next(); + + Tensor tfResult = evaluateTF(tensorFlowModel, output, model.inputs()); + Tensor vespaResult = evaluateVespa(model, output, model.inputs()); + Tensor onnxResult = evaluateVespa(onnxImportedModel, onnxOutput, model.inputs()); + + if ( ! tfResult.equals(vespaResult) ) { + return reportAndFail(report, opset, tfModel, "Diff between tf and imported tf evaluation:\n\t" + tfResult + "\n\t" + vespaResult); + } + if ( ! vespaResult.equals(onnxResult) ) { + return reportAndFail(report, opset, tfModel, "Diff between imported tf eval and onnx eval:\n\t" + vespaResult + "\n\t" + onnxResult); + } + + return reportAndSucceed(report, opset, tfModel, "Ok"); + } + + private Pair<Integer, String> tf2onnxConvert(String savedModel, String output, int opset) throws IOException { + ProcessExecuter executer = new ProcessExecuter(); + String job = "python3 -m tf2onnx.convert --saved-model " + savedModel + " --output " + output + " --opset " + opset; + return executer.exec(job); + } + + private static class Report { + final ObjectMapper mapper = new ObjectMapper(); + final Map<String, ArrayNode> results = new HashMap<>(); + + public boolean add(String model, int opset, boolean ok, String desc) { + ObjectNode obj = mapper.createObjectNode(). + put("opset", opset). + put("ok", ok). + put("desc", desc); + results.computeIfAbsent(model, r -> mapper.createArrayNode()).add(obj); + return ok; + } + + public String toString() { + ArrayNode array = mapper.createArrayNode(); + results.forEach((key, value) -> array.add(mapper.createObjectNode(). + put("model", key). + set("tests", value))); + try { + return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(array); + } catch (JsonProcessingException e) { + return e.getMessage(); + } + } + } + + private static boolean reportAndFail(Report report, int opset, String model, String desc) { + return report.add(model, opset, false, desc); + } + + private static boolean reportAndSucceed(Report report, int opset, String model, String desc) { + return report.add(model, opset, true, desc); + } + +} diff --git a/model-integration/src/test/models/tensorflow/external/Model_A/optimized_v2/saved_model.pbtxt b/model-integration/src/test/models/tensorflow/external/Model_A/optimized_v2/saved_model.pbtxt new file mode 100644 index 00000000000..d2dc51ac328 --- /dev/null +++ b/model-integration/src/test/models/tensorflow/external/Model_A/optimized_v2/saved_model.pbtxt @@ -0,0 +1,1368 @@ +saved_model_schema_version: 1 +meta_graphs { + meta_info_def { + stripped_op_list { + op { + name: "Add" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_UINT8 + type: DT_INT8 + type: DT_INT16 + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + type: DT_STRING + } + } + } + } + op { + name: "BiasAdd" + input_arg { + name: "value" + type_attr: "T" + } + input_arg { + name: "bias" + type_attr: "T" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_UINT8 + type: DT_INT16 + type: DT_INT8 + type: DT_COMPLEX64 + type: DT_INT64 + type: DT_QINT8 + type: DT_QUINT8 + type: DT_QINT32 + type: DT_BFLOAT16 + type: DT_UINT16 + type: DT_COMPLEX128 + type: DT_HALF + type: DT_UINT32 + type: DT_UINT64 + } + } + } + attr { + name: "data_format" + type: "string" + default_value { + s: "NHWC" + } + allowed_values { + list { + s: "NHWC" + s: "NCHW" + } + } + } + } + op { + name: "Const" + output_arg { + name: "output" + type_attr: "dtype" + } + attr { + name: "value" + type: "tensor" + } + attr { + name: "dtype" + type: "type" + } + } + op { + name: "ExpandDims" + input_arg { + name: "input" + type_attr: "T" + } + input_arg { + name: "dim" + type_attr: "Tdim" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "T" + type: "type" + } + attr { + name: "Tdim" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + op { + name: "MatMul" + input_arg { + name: "a" + type_attr: "T" + } + input_arg { + name: "b" + type_attr: "T" + } + output_arg { + name: "product" + type_attr: "T" + } + attr { + name: "transpose_a" + type: "bool" + default_value { + b: false + } + } + attr { + name: "transpose_b" + type: "bool" + default_value { + b: false + } + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "Maximum" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_INT64 + } + } + } + is_commutative: true + } + op { + name: "Mul" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_UINT8 + type: DT_INT8 + type: DT_UINT16 + type: DT_INT16 + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + is_commutative: true + } + op { + name: "Placeholder" + output_arg { + name: "output" + type_attr: "dtype" + } + attr { + name: "dtype" + type: "type" + } + attr { + name: "shape" + type: "shape" + default_value { + shape { + unknown_rank: true + } + } + } + } + op { + name: "PlaceholderWithDefault" + input_arg { + name: "input" + type_attr: "dtype" + } + output_arg { + name: "output" + type_attr: "dtype" + } + attr { + name: "dtype" + type: "type" + } + attr { + name: "shape" + type: "shape" + } + } + op { + name: "Rsqrt" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "Sigmoid" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "Square" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "Sum" + input_arg { + name: "input" + type_attr: "T" + } + input_arg { + name: "reduction_indices" + type_attr: "Tidx" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "keep_dims" + type: "bool" + default_value { + b: false + } + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_UINT8 + type: DT_INT16 + type: DT_INT8 + type: DT_COMPLEX64 + type: DT_INT64 + type: DT_QINT8 + type: DT_QUINT8 + type: DT_QINT32 + type: DT_BFLOAT16 + type: DT_UINT16 + type: DT_COMPLEX128 + type: DT_HALF + type: DT_UINT32 + type: DT_UINT64 + } + } + } + attr { + name: "Tidx" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + } + tags: "serve" + tensorflow_version: "1.13.1" + tensorflow_git_version: "b\'v1.13.1-0-g6612da8951\'" + } + graph_def { + node { + name: "keras_learning_phase/input" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_BOOL + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_BOOL + tensor_shape { + } + bool_val: false + } + } + } + } + node { + name: "keras_learning_phase" + op: "PlaceholderWithDefault" + input: "keras_learning_phase/input" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_BOOL + } + } + attr { + key: "shape" + value { + shape { + } + } + } + } + node { + name: "dot_0/l2_normalize/Maximum/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 9.999999960041972e-13 + } + } + } + } + node { + name: "dot_0/l2_normalize/Sum/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "dense_out/kernel" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + float_val: -1.049525499343872 + } + } + } + } + node { + name: "batch_norm/moving_mean" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } + } + node { + name: "batch_norm/batchnorm/mul/_0__cf__0" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.9995003938674927 + } + } + } + } + node { + name: "batch_norm/batchnorm/sub/_1__cf__1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } + } + node { + name: "input_embedding_user_guid" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1/Square" + op: "Square" + input: "input_embedding_user_guid" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1/Sum" + op: "Sum" + input: "dot_0/l2_normalize_1/Square" + input: "dot_0/l2_normalize/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: true + } + } + } + node { + name: "dot_0/l2_normalize_1/Maximum" + op: "Maximum" + input: "dot_0/l2_normalize_1/Sum" + input: "dot_0/l2_normalize/Maximum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1/Rsqrt" + op: "Rsqrt" + input: "dot_0/l2_normalize_1/Maximum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1" + op: "Mul" + input: "input_embedding_user_guid" + input: "dot_0/l2_normalize_1/Rsqrt" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "input_embedding_product_slug" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + node { + name: "dot_0/l2_normalize/Square" + op: "Square" + input: "input_embedding_product_slug" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize/Sum" + op: "Sum" + input: "dot_0/l2_normalize/Square" + input: "dot_0/l2_normalize/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: true + } + } + } + node { + name: "dot_0/l2_normalize/Maximum" + op: "Maximum" + input: "dot_0/l2_normalize/Sum" + input: "dot_0/l2_normalize/Maximum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize/Rsqrt" + op: "Rsqrt" + input: "dot_0/l2_normalize/Maximum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize" + op: "Mul" + input: "input_embedding_product_slug" + input: "dot_0/l2_normalize/Rsqrt" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/Mul" + op: "Mul" + input: "dot_0/l2_normalize" + input: "dot_0/l2_normalize_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/Sum" + op: "Sum" + input: "dot_0/Mul" + input: "dot_0/l2_normalize/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "dot_0/ExpandDims" + op: "ExpandDims" + input: "dot_0/Sum" + input: "dot_0/l2_normalize/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "batch_norm/batchnorm/mul_1" + op: "Mul" + input: "dot_0/ExpandDims" + input: "batch_norm/batchnorm/mul/_0__cf__0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "batch_norm/batchnorm/add_1" + op: "Add" + input: "batch_norm/batchnorm/mul_1" + input: "batch_norm/batchnorm/sub/_1__cf__1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dense_out/MatMul" + op: "MatMul" + input: "batch_norm/batchnorm/add_1" + input: "dense_out/kernel" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } + } + node { + name: "dense_out/BiasAdd" + op: "BiasAdd" + input: "dense_out/MatMul" + input: "batch_norm/moving_mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + } + node { + name: "dense_out/Sigmoid" + op: "Sigmoid" + input: "dense_out/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + versions { + } + } + signature_def { + key: "serving_default" + value { + inputs { + key: "input_embedding_product_slug" + value { + name: "input_embedding_product_slug:0" + dtype: DT_FLOAT + tensor_shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + inputs { + key: "input_embedding_user_guid" + value { + name: "input_embedding_user_guid:0" + dtype: DT_FLOAT + tensor_shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + outputs { + key: "output" + value { + name: "dense_out/Sigmoid:0" + dtype: DT_FLOAT + tensor_shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + method_name: "tensorflow/serving/predict" + } + } +} diff --git a/model-integration/src/test/models/tensorflow/external/Model_B/factorization_machine_v1/export/optimized/saved_model.pbtxt b/model-integration/src/test/models/tensorflow/external/Model_B/factorization_machine_v1/export/optimized/saved_model.pbtxt new file mode 100644 index 00000000000..102428b2cf2 --- /dev/null +++ b/model-integration/src/test/models/tensorflow/external/Model_B/factorization_machine_v1/export/optimized/saved_model.pbtxt @@ -0,0 +1,1368 @@ +saved_model_schema_version: 1 +meta_graphs { + meta_info_def { + stripped_op_list { + op { + name: "Add" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_UINT8 + type: DT_INT8 + type: DT_INT16 + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + type: DT_STRING + } + } + } + } + op { + name: "BiasAdd" + input_arg { + name: "value" + type_attr: "T" + } + input_arg { + name: "bias" + type_attr: "T" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_UINT8 + type: DT_INT16 + type: DT_INT8 + type: DT_COMPLEX64 + type: DT_INT64 + type: DT_QINT8 + type: DT_QUINT8 + type: DT_QINT32 + type: DT_BFLOAT16 + type: DT_UINT16 + type: DT_COMPLEX128 + type: DT_HALF + type: DT_UINT32 + type: DT_UINT64 + } + } + } + attr { + name: "data_format" + type: "string" + default_value { + s: "NHWC" + } + allowed_values { + list { + s: "NHWC" + s: "NCHW" + } + } + } + } + op { + name: "Const" + output_arg { + name: "output" + type_attr: "dtype" + } + attr { + name: "value" + type: "tensor" + } + attr { + name: "dtype" + type: "type" + } + } + op { + name: "ExpandDims" + input_arg { + name: "input" + type_attr: "T" + } + input_arg { + name: "dim" + type_attr: "Tdim" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "T" + type: "type" + } + attr { + name: "Tdim" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + op { + name: "MatMul" + input_arg { + name: "a" + type_attr: "T" + } + input_arg { + name: "b" + type_attr: "T" + } + output_arg { + name: "product" + type_attr: "T" + } + attr { + name: "transpose_a" + type: "bool" + default_value { + b: false + } + } + attr { + name: "transpose_b" + type: "bool" + default_value { + b: false + } + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "Maximum" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_INT64 + } + } + } + is_commutative: true + } + op { + name: "Mul" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_UINT8 + type: DT_INT8 + type: DT_UINT16 + type: DT_INT16 + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + is_commutative: true + } + op { + name: "Placeholder" + output_arg { + name: "output" + type_attr: "dtype" + } + attr { + name: "dtype" + type: "type" + } + attr { + name: "shape" + type: "shape" + default_value { + shape { + unknown_rank: true + } + } + } + } + op { + name: "PlaceholderWithDefault" + input_arg { + name: "input" + type_attr: "dtype" + } + output_arg { + name: "output" + type_attr: "dtype" + } + attr { + name: "dtype" + type: "type" + } + attr { + name: "shape" + type: "shape" + } + } + op { + name: "Rsqrt" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "Sigmoid" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "Square" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "Sum" + input_arg { + name: "input" + type_attr: "T" + } + input_arg { + name: "reduction_indices" + type_attr: "Tidx" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "keep_dims" + type: "bool" + default_value { + b: false + } + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_UINT8 + type: DT_INT16 + type: DT_INT8 + type: DT_COMPLEX64 + type: DT_INT64 + type: DT_QINT8 + type: DT_QUINT8 + type: DT_QINT32 + type: DT_BFLOAT16 + type: DT_UINT16 + type: DT_COMPLEX128 + type: DT_HALF + type: DT_UINT32 + type: DT_UINT64 + } + } + } + attr { + name: "Tidx" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + } + tags: "serve" + tensorflow_version: "1.13.1" + tensorflow_git_version: "b\'v1.13.1-0-g6612da8951\'" + } + graph_def { + node { + name: "keras_learning_phase/input" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_BOOL + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_BOOL + tensor_shape { + } + bool_val: false + } + } + } + } + node { + name: "keras_learning_phase" + op: "PlaceholderWithDefault" + input: "keras_learning_phase/input" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_BOOL + } + } + attr { + key: "shape" + value { + shape { + } + } + } + } + node { + name: "dot_0/l2_normalize/Maximum/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 9.999999960041972e-13 + } + } + } + } + node { + name: "dot_0/l2_normalize/Sum/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "dense_out/kernel" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + float_val: -1.278536081314087 + } + } + } + } + node { + name: "batch_norm/moving_mean" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } + } + node { + name: "batch_norm/batchnorm/mul/_0__cf__2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.9995003938674927 + } + } + } + } + node { + name: "batch_norm/batchnorm/sub/_1__cf__3" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } + } + node { + name: "input_embedding_user_guid" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1/Square" + op: "Square" + input: "input_embedding_user_guid" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1/Sum" + op: "Sum" + input: "dot_0/l2_normalize_1/Square" + input: "dot_0/l2_normalize/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: true + } + } + } + node { + name: "dot_0/l2_normalize_1/Maximum" + op: "Maximum" + input: "dot_0/l2_normalize_1/Sum" + input: "dot_0/l2_normalize/Maximum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1/Rsqrt" + op: "Rsqrt" + input: "dot_0/l2_normalize_1/Maximum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1" + op: "Mul" + input: "input_embedding_user_guid" + input: "dot_0/l2_normalize_1/Rsqrt" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "input_embedding_product_slug" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + node { + name: "dot_0/l2_normalize/Square" + op: "Square" + input: "input_embedding_product_slug" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize/Sum" + op: "Sum" + input: "dot_0/l2_normalize/Square" + input: "dot_0/l2_normalize/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: true + } + } + } + node { + name: "dot_0/l2_normalize/Maximum" + op: "Maximum" + input: "dot_0/l2_normalize/Sum" + input: "dot_0/l2_normalize/Maximum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize/Rsqrt" + op: "Rsqrt" + input: "dot_0/l2_normalize/Maximum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize" + op: "Mul" + input: "input_embedding_product_slug" + input: "dot_0/l2_normalize/Rsqrt" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/Mul" + op: "Mul" + input: "dot_0/l2_normalize" + input: "dot_0/l2_normalize_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/Sum" + op: "Sum" + input: "dot_0/Mul" + input: "dot_0/l2_normalize/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "dot_0/ExpandDims" + op: "ExpandDims" + input: "dot_0/Sum" + input: "dot_0/l2_normalize/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "batch_norm/batchnorm/mul_1" + op: "Mul" + input: "dot_0/ExpandDims" + input: "batch_norm/batchnorm/mul/_0__cf__2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "batch_norm/batchnorm/add_1" + op: "Add" + input: "batch_norm/batchnorm/mul_1" + input: "batch_norm/batchnorm/sub/_1__cf__3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dense_out/MatMul" + op: "MatMul" + input: "batch_norm/batchnorm/add_1" + input: "dense_out/kernel" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } + } + node { + name: "dense_out/BiasAdd" + op: "BiasAdd" + input: "dense_out/MatMul" + input: "batch_norm/moving_mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + } + node { + name: "dense_out/Sigmoid" + op: "Sigmoid" + input: "dense_out/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + versions { + } + } + signature_def { + key: "serving_default" + value { + inputs { + key: "input_embedding_product_slug" + value { + name: "input_embedding_product_slug:0" + dtype: DT_FLOAT + tensor_shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + inputs { + key: "input_embedding_user_guid" + value { + name: "input_embedding_user_guid:0" + dtype: DT_FLOAT + tensor_shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + outputs { + key: "output" + value { + name: "dense_out/Sigmoid:0" + dtype: DT_FLOAT + tensor_shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + method_name: "tensorflow/serving/predict" + } + } +} diff --git a/model-integration/src/test/models/tensorflow/external/Model_B/factorization_machine_v1/export/standard/saved_model.pbtxt b/model-integration/src/test/models/tensorflow/external/Model_B/factorization_machine_v1/export/standard/saved_model.pbtxt new file mode 100644 index 00000000000..50aee0ebcf7 --- /dev/null +++ b/model-integration/src/test/models/tensorflow/external/Model_B/factorization_machine_v1/export/standard/saved_model.pbtxt @@ -0,0 +1,11403 @@ +saved_model_schema_version: 1 +meta_graphs { + meta_info_def { + stripped_op_list { + op { + name: "Abs" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_INT64 + } + } + } + } + op { + name: "Add" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_UINT8 + type: DT_INT8 + type: DT_INT16 + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + type: DT_STRING + } + } + } + } + op { + name: "Assert" + input_arg { + name: "condition" + type: DT_BOOL + } + input_arg { + name: "data" + type_list_attr: "T" + } + attr { + name: "T" + type: "list(type)" + has_minimum: true + minimum: 1 + } + attr { + name: "summarize" + type: "int" + default_value { + i: 3 + } + } + is_stateful: true + } + op { + name: "AssignAddVariableOp" + input_arg { + name: "resource" + type: DT_RESOURCE + } + input_arg { + name: "value" + type_attr: "dtype" + } + attr { + name: "dtype" + type: "type" + } + is_stateful: true + } + op { + name: "AssignVariableOp" + input_arg { + name: "resource" + type: DT_RESOURCE + } + input_arg { + name: "value" + type_attr: "dtype" + } + attr { + name: "dtype" + type: "type" + } + is_stateful: true + } + op { + name: "BiasAdd" + input_arg { + name: "value" + type_attr: "T" + } + input_arg { + name: "bias" + type_attr: "T" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_UINT8 + type: DT_INT16 + type: DT_INT8 + type: DT_COMPLEX64 + type: DT_INT64 + type: DT_QINT8 + type: DT_QUINT8 + type: DT_QINT32 + type: DT_BFLOAT16 + type: DT_UINT16 + type: DT_COMPLEX128 + type: DT_HALF + type: DT_UINT32 + type: DT_UINT64 + } + } + } + attr { + name: "data_format" + type: "string" + default_value { + s: "NHWC" + } + allowed_values { + list { + s: "NHWC" + s: "NCHW" + } + } + } + } + op { + name: "Cast" + input_arg { + name: "x" + type_attr: "SrcT" + } + output_arg { + name: "y" + type_attr: "DstT" + } + attr { + name: "SrcT" + type: "type" + } + attr { + name: "DstT" + type: "type" + } + attr { + name: "Truncate" + type: "bool" + default_value { + b: false + } + } + } + op { + name: "ConcatV2" + input_arg { + name: "values" + type_attr: "T" + number_attr: "N" + } + input_arg { + name: "axis" + type_attr: "Tidx" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "N" + type: "int" + has_minimum: true + minimum: 2 + } + attr { + name: "T" + type: "type" + } + attr { + name: "Tidx" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + op { + name: "Const" + output_arg { + name: "output" + type_attr: "dtype" + } + attr { + name: "value" + type: "tensor" + } + attr { + name: "dtype" + type: "type" + } + } + op { + name: "DenseToDenseSetOperation" + input_arg { + name: "set1" + type_attr: "T" + } + input_arg { + name: "set2" + type_attr: "T" + } + output_arg { + name: "result_indices" + type: DT_INT64 + } + output_arg { + name: "result_values" + type_attr: "T" + } + output_arg { + name: "result_shape" + type: DT_INT64 + } + attr { + name: "set_operation" + type: "string" + } + attr { + name: "validate_indices" + type: "bool" + default_value { + b: true + } + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_INT8 + type: DT_INT16 + type: DT_INT32 + type: DT_INT64 + type: DT_UINT8 + type: DT_UINT16 + type: DT_STRING + } + } + } + } + op { + name: "DivNoNan" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_FLOAT + type: DT_DOUBLE + } + } + } + } + op { + name: "Equal" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type: DT_BOOL + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_UINT8 + type: DT_INT8 + type: DT_INT16 + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_QUINT8 + type: DT_QINT8 + type: DT_QINT32 + type: DT_STRING + type: DT_BOOL + type: DT_COMPLEX128 + } + } + } + is_commutative: true + } + op { + name: "Exp" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "ExpandDims" + input_arg { + name: "input" + type_attr: "T" + } + input_arg { + name: "dim" + type_attr: "Tdim" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "T" + type: "type" + } + attr { + name: "Tdim" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + op { + name: "Fill" + input_arg { + name: "dims" + type_attr: "index_type" + } + input_arg { + name: "value" + type_attr: "T" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "T" + type: "type" + } + attr { + name: "index_type" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + op { + name: "Greater" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type: DT_BOOL + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_UINT8 + type: DT_INT16 + type: DT_INT8 + type: DT_INT64 + type: DT_BFLOAT16 + type: DT_UINT16 + type: DT_HALF + type: DT_UINT32 + type: DT_UINT64 + } + } + } + } + op { + name: "GreaterEqual" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type: DT_BOOL + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_UINT8 + type: DT_INT16 + type: DT_INT8 + type: DT_INT64 + type: DT_BFLOAT16 + type: DT_UINT16 + type: DT_HALF + type: DT_UINT32 + type: DT_UINT64 + } + } + } + } + op { + name: "Identity" + input_arg { + name: "input" + type_attr: "T" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "T" + type: "type" + } + } + op { + name: "Log" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "Log1p" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "MatMul" + input_arg { + name: "a" + type_attr: "T" + } + input_arg { + name: "b" + type_attr: "T" + } + output_arg { + name: "product" + type_attr: "T" + } + attr { + name: "transpose_a" + type: "bool" + default_value { + b: false + } + } + attr { + name: "transpose_b" + type: "bool" + default_value { + b: false + } + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "Maximum" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_INT64 + } + } + } + is_commutative: true + } + op { + name: "Mean" + input_arg { + name: "input" + type_attr: "T" + } + input_arg { + name: "reduction_indices" + type_attr: "Tidx" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "keep_dims" + type: "bool" + default_value { + b: false + } + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_UINT8 + type: DT_INT16 + type: DT_INT8 + type: DT_COMPLEX64 + type: DT_INT64 + type: DT_QINT8 + type: DT_QUINT8 + type: DT_QINT32 + type: DT_BFLOAT16 + type: DT_UINT16 + type: DT_COMPLEX128 + type: DT_HALF + type: DT_UINT32 + type: DT_UINT64 + } + } + } + attr { + name: "Tidx" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + op { + name: "Merge" + input_arg { + name: "inputs" + type_attr: "T" + number_attr: "N" + } + output_arg { + name: "output" + type_attr: "T" + } + output_arg { + name: "value_index" + type: DT_INT32 + } + attr { + name: "T" + type: "type" + } + attr { + name: "N" + type: "int" + has_minimum: true + minimum: 1 + } + } + op { + name: "MergeV2Checkpoints" + input_arg { + name: "checkpoint_prefixes" + type: DT_STRING + } + input_arg { + name: "destination_prefix" + type: DT_STRING + } + attr { + name: "delete_old_dirs" + type: "bool" + default_value { + b: true + } + } + is_stateful: true + } + op { + name: "Minimum" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_INT64 + } + } + } + is_commutative: true + } + op { + name: "Mul" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_UINT8 + type: DT_INT8 + type: DT_UINT16 + type: DT_INT16 + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + is_commutative: true + } + op { + name: "Neg" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "NoOp" + } + op { + name: "Pack" + input_arg { + name: "values" + type_attr: "T" + number_attr: "N" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "N" + type: "int" + has_minimum: true + minimum: 1 + } + attr { + name: "T" + type: "type" + } + attr { + name: "axis" + type: "int" + default_value { + i: 0 + } + } + } + op { + name: "Placeholder" + output_arg { + name: "output" + type_attr: "dtype" + } + attr { + name: "dtype" + type: "type" + } + attr { + name: "shape" + type: "shape" + default_value { + shape { + unknown_rank: true + } + } + } + } + op { + name: "PlaceholderWithDefault" + input_arg { + name: "input" + type_attr: "dtype" + } + output_arg { + name: "output" + type_attr: "dtype" + } + attr { + name: "dtype" + type: "type" + } + attr { + name: "shape" + type: "shape" + } + } + op { + name: "ReadVariableOp" + input_arg { + name: "resource" + type: DT_RESOURCE + } + output_arg { + name: "value" + type_attr: "dtype" + } + attr { + name: "dtype" + type: "type" + } + is_stateful: true + } + op { + name: "RealDiv" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_UINT8 + type: DT_INT8 + type: DT_UINT16 + type: DT_INT16 + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "RestoreV2" + input_arg { + name: "prefix" + type: DT_STRING + } + input_arg { + name: "tensor_names" + type: DT_STRING + } + input_arg { + name: "shape_and_slices" + type: DT_STRING + } + output_arg { + name: "tensors" + type_list_attr: "dtypes" + } + attr { + name: "dtypes" + type: "list(type)" + has_minimum: true + minimum: 1 + } + is_stateful: true + } + op { + name: "Rsqrt" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "SaveV2" + input_arg { + name: "prefix" + type: DT_STRING + } + input_arg { + name: "tensor_names" + type: DT_STRING + } + input_arg { + name: "shape_and_slices" + type: DT_STRING + } + input_arg { + name: "tensors" + type_list_attr: "dtypes" + } + attr { + name: "dtypes" + type: "list(type)" + has_minimum: true + minimum: 1 + } + is_stateful: true + } + op { + name: "Select" + input_arg { + name: "condition" + type: DT_BOOL + } + input_arg { + name: "t" + type_attr: "T" + } + input_arg { + name: "e" + type_attr: "T" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "T" + type: "type" + } + } + op { + name: "Shape" + input_arg { + name: "input" + type_attr: "T" + } + output_arg { + name: "output" + type_attr: "out_type" + } + attr { + name: "T" + type: "type" + } + attr { + name: "out_type" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + op { + name: "ShardedFilename" + input_arg { + name: "basename" + type: DT_STRING + } + input_arg { + name: "shard" + type: DT_INT32 + } + input_arg { + name: "num_shards" + type: DT_INT32 + } + output_arg { + name: "filename" + type: DT_STRING + } + } + op { + name: "Sigmoid" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "Size" + input_arg { + name: "input" + type_attr: "T" + } + output_arg { + name: "output" + type_attr: "out_type" + } + attr { + name: "T" + type: "type" + } + attr { + name: "out_type" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + op { + name: "Square" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "StringJoin" + input_arg { + name: "inputs" + type: DT_STRING + number_attr: "N" + } + output_arg { + name: "output" + type: DT_STRING + } + attr { + name: "N" + type: "int" + has_minimum: true + minimum: 1 + } + attr { + name: "separator" + type: "string" + default_value { + s: "" + } + } + } + op { + name: "Sub" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_UINT8 + type: DT_INT8 + type: DT_UINT16 + type: DT_INT16 + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "Sum" + input_arg { + name: "input" + type_attr: "T" + } + input_arg { + name: "reduction_indices" + type_attr: "Tidx" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "keep_dims" + type: "bool" + default_value { + b: false + } + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_UINT8 + type: DT_INT16 + type: DT_INT8 + type: DT_COMPLEX64 + type: DT_INT64 + type: DT_QINT8 + type: DT_QUINT8 + type: DT_QINT32 + type: DT_BFLOAT16 + type: DT_UINT16 + type: DT_COMPLEX128 + type: DT_HALF + type: DT_UINT32 + type: DT_UINT64 + } + } + } + attr { + name: "Tidx" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + op { + name: "Switch" + input_arg { + name: "data" + type_attr: "T" + } + input_arg { + name: "pred" + type: DT_BOOL + } + output_arg { + name: "output_false" + type_attr: "T" + } + output_arg { + name: "output_true" + type_attr: "T" + } + attr { + name: "T" + type: "type" + } + } + op { + name: "TruncatedNormal" + input_arg { + name: "shape" + type_attr: "T" + } + output_arg { + name: "output" + type_attr: "dtype" + } + attr { + name: "seed" + type: "int" + default_value { + i: 0 + } + } + attr { + name: "seed2" + type: "int" + default_value { + i: 0 + } + } + attr { + name: "dtype" + type: "type" + allowed_values { + list { + type: DT_HALF + type: DT_BFLOAT16 + type: DT_FLOAT + type: DT_DOUBLE + } + } + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + is_stateful: true + } + op { + name: "VarHandleOp" + output_arg { + name: "resource" + type: DT_RESOURCE + } + attr { + name: "container" + type: "string" + default_value { + s: "" + } + } + attr { + name: "shared_name" + type: "string" + default_value { + s: "" + } + } + attr { + name: "dtype" + type: "type" + } + attr { + name: "shape" + type: "shape" + } + is_stateful: true + } + op { + name: "VarIsInitializedOp" + input_arg { + name: "resource" + type: DT_RESOURCE + } + output_arg { + name: "is_initialized" + type: DT_BOOL + } + is_stateful: true + } + op { + name: "ZerosLike" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + } + } + } + tags: "serve" + tensorflow_version: "1.13.1" + tensorflow_git_version: "b\'v1.13.1-0-g6612da8951\'" + } + graph_def { + node { + name: "keras_learning_phase/input" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_BOOL + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_BOOL + tensor_shape { + } + bool_val: false + } + } + } + } + node { + name: "keras_learning_phase" + op: "PlaceholderWithDefault" + input: "keras_learning_phase/input" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_BOOL + } + } + attr { + key: "shape" + value { + shape { + } + } + } + } + node { + name: "Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } + } + node { + name: "input_embedding_product_slug" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + node { + name: "input_embedding_user_guid" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + node { + name: "dot_0/l2_normalize/Square" + op: "Square" + input: "input_embedding_product_slug" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize/Sum/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "dot_0/l2_normalize/Sum" + op: "Sum" + input: "dot_0/l2_normalize/Square" + input: "dot_0/l2_normalize/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: true + } + } + } + node { + name: "dot_0/l2_normalize/Maximum/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 9.999999960041972e-13 + } + } + } + } + node { + name: "dot_0/l2_normalize/Maximum" + op: "Maximum" + input: "dot_0/l2_normalize/Sum" + input: "dot_0/l2_normalize/Maximum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize/Rsqrt" + op: "Rsqrt" + input: "dot_0/l2_normalize/Maximum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize" + op: "Mul" + input: "input_embedding_product_slug" + input: "dot_0/l2_normalize/Rsqrt" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1/Square" + op: "Square" + input: "input_embedding_user_guid" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1/Sum/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "dot_0/l2_normalize_1/Sum" + op: "Sum" + input: "dot_0/l2_normalize_1/Square" + input: "dot_0/l2_normalize_1/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: true + } + } + } + node { + name: "dot_0/l2_normalize_1/Maximum/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 9.999999960041972e-13 + } + } + } + } + node { + name: "dot_0/l2_normalize_1/Maximum" + op: "Maximum" + input: "dot_0/l2_normalize_1/Sum" + input: "dot_0/l2_normalize_1/Maximum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1/Rsqrt" + op: "Rsqrt" + input: "dot_0/l2_normalize_1/Maximum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1" + op: "Mul" + input: "input_embedding_user_guid" + input: "dot_0/l2_normalize_1/Rsqrt" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/Mul" + op: "Mul" + input: "dot_0/l2_normalize" + input: "dot_0/l2_normalize_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/Sum/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "dot_0/Sum" + op: "Sum" + input: "dot_0/Mul" + input: "dot_0/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "dot_0/ExpandDims/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "dot_0/ExpandDims" + op: "ExpandDims" + input: "dot_0/Sum" + input: "dot_0/ExpandDims/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "batch_norm/gamma/Initializer/ones" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@batch_norm/gamma" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 1.0 + } + } + } + } + node { + name: "batch_norm/gamma" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@batch_norm/gamma" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "batch_norm/gamma" + } + } + } + node { + name: "batch_norm/gamma/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "batch_norm/gamma" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "batch_norm/gamma/Assign" + op: "AssignVariableOp" + input: "batch_norm/gamma" + input: "batch_norm/gamma/Initializer/ones" + attr { + key: "_class" + value { + list { + s: "loc:@batch_norm/gamma" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "batch_norm/gamma/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "batch_norm/gamma" + attr { + key: "_class" + value { + list { + s: "loc:@batch_norm/gamma" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "batch_norm/beta/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@batch_norm/beta" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } + } + node { + name: "batch_norm/beta" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@batch_norm/beta" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "batch_norm/beta" + } + } + } + node { + name: "batch_norm/beta/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "batch_norm/beta" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "batch_norm/beta/Assign" + op: "AssignVariableOp" + input: "batch_norm/beta" + input: "batch_norm/beta/Initializer/zeros" + attr { + key: "_class" + value { + list { + s: "loc:@batch_norm/beta" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "batch_norm/beta/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "batch_norm/beta" + attr { + key: "_class" + value { + list { + s: "loc:@batch_norm/beta" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "batch_norm/moving_mean/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@batch_norm/moving_mean" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } + } + node { + name: "batch_norm/moving_mean" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@batch_norm/moving_mean" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "batch_norm/moving_mean" + } + } + } + node { + name: "batch_norm/moving_mean/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "batch_norm/moving_mean" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "batch_norm/moving_mean/Assign" + op: "AssignVariableOp" + input: "batch_norm/moving_mean" + input: "batch_norm/moving_mean/Initializer/zeros" + attr { + key: "_class" + value { + list { + s: "loc:@batch_norm/moving_mean" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "batch_norm/moving_mean/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "batch_norm/moving_mean" + attr { + key: "_class" + value { + list { + s: "loc:@batch_norm/moving_mean" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "batch_norm/moving_variance/Initializer/ones" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@batch_norm/moving_variance" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 1.0 + } + } + } + } + node { + name: "batch_norm/moving_variance" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@batch_norm/moving_variance" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "batch_norm/moving_variance" + } + } + } + node { + name: "batch_norm/moving_variance/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "batch_norm/moving_variance" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "batch_norm/moving_variance/Assign" + op: "AssignVariableOp" + input: "batch_norm/moving_variance" + input: "batch_norm/moving_variance/Initializer/ones" + attr { + key: "_class" + value { + list { + s: "loc:@batch_norm/moving_variance" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "batch_norm/moving_variance/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "batch_norm/moving_variance" + attr { + key: "_class" + value { + list { + s: "loc:@batch_norm/moving_variance" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "batch_norm/batchnorm/ReadVariableOp" + op: "ReadVariableOp" + input: "batch_norm/moving_variance" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "batch_norm/batchnorm/add/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0010000000474974513 + } + } + } + } + node { + name: "batch_norm/batchnorm/add" + op: "Add" + input: "batch_norm/batchnorm/ReadVariableOp" + input: "batch_norm/batchnorm/add/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + } + node { + name: "batch_norm/batchnorm/Rsqrt" + op: "Rsqrt" + input: "batch_norm/batchnorm/add" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + } + node { + name: "batch_norm/batchnorm/mul/ReadVariableOp" + op: "ReadVariableOp" + input: "batch_norm/gamma" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "batch_norm/batchnorm/mul" + op: "Mul" + input: "batch_norm/batchnorm/Rsqrt" + input: "batch_norm/batchnorm/mul/ReadVariableOp" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + } + node { + name: "batch_norm/batchnorm/mul_1" + op: "Mul" + input: "dot_0/ExpandDims" + input: "batch_norm/batchnorm/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "batch_norm/batchnorm/ReadVariableOp_1" + op: "ReadVariableOp" + input: "batch_norm/moving_mean" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "batch_norm/batchnorm/mul_2" + op: "Mul" + input: "batch_norm/batchnorm/ReadVariableOp_1" + input: "batch_norm/batchnorm/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + } + node { + name: "batch_norm/batchnorm/ReadVariableOp_2" + op: "ReadVariableOp" + input: "batch_norm/beta" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "batch_norm/batchnorm/sub" + op: "Sub" + input: "batch_norm/batchnorm/ReadVariableOp_2" + input: "batch_norm/batchnorm/mul_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + } + node { + name: "batch_norm/batchnorm/add_1" + op: "Add" + input: "batch_norm/batchnorm/mul_1" + input: "batch_norm/batchnorm/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dense_out/kernel/Initializer/truncated_normal/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@dense_out/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } + } + node { + name: "dense_out/kernel/Initializer/truncated_normal/mean" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@dense_out/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } + } + node { + name: "dense_out/kernel/Initializer/truncated_normal/stddev" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@dense_out/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.607744812965393 + } + } + } + } + node { + name: "dense_out/kernel/Initializer/truncated_normal/TruncatedNormal" + op: "TruncatedNormal" + input: "dense_out/kernel/Initializer/truncated_normal/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_out/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 0 + } + } + attr { + key: "seed2" + value { + i: 0 + } + } + } + node { + name: "dense_out/kernel/Initializer/truncated_normal/mul" + op: "Mul" + input: "dense_out/kernel/Initializer/truncated_normal/TruncatedNormal" + input: "dense_out/kernel/Initializer/truncated_normal/stddev" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_out/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dense_out/kernel/Initializer/truncated_normal" + op: "Add" + input: "dense_out/kernel/Initializer/truncated_normal/mul" + input: "dense_out/kernel/Initializer/truncated_normal/mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_out/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dense_out/kernel" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@dense_out/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "dense_out/kernel" + } + } + } + node { + name: "dense_out/kernel/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "dense_out/kernel" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "dense_out/kernel/Assign" + op: "AssignVariableOp" + input: "dense_out/kernel" + input: "dense_out/kernel/Initializer/truncated_normal" + attr { + key: "_class" + value { + list { + s: "loc:@dense_out/kernel" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "dense_out/kernel/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "dense_out/kernel" + attr { + key: "_class" + value { + list { + s: "loc:@dense_out/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "dense_out/bias/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@dense_out/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } + } + node { + name: "dense_out/bias" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@dense_out/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "dense_out/bias" + } + } + } + node { + name: "dense_out/bias/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "dense_out/bias" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "dense_out/bias/Assign" + op: "AssignVariableOp" + input: "dense_out/bias" + input: "dense_out/bias/Initializer/zeros" + attr { + key: "_class" + value { + list { + s: "loc:@dense_out/bias" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "dense_out/bias/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "dense_out/bias" + attr { + key: "_class" + value { + list { + s: "loc:@dense_out/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "dense_out/MatMul/ReadVariableOp" + op: "ReadVariableOp" + input: "dense_out/kernel" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "dense_out/MatMul" + op: "MatMul" + input: "batch_norm/batchnorm/add_1" + input: "dense_out/MatMul/ReadVariableOp" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } + } + node { + name: "dense_out/BiasAdd/ReadVariableOp" + op: "ReadVariableOp" + input: "dense_out/bias" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "dense_out/BiasAdd" + op: "BiasAdd" + input: "dense_out/MatMul" + input: "dense_out/BiasAdd/ReadVariableOp" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + } + node { + name: "dense_out/Sigmoid" + op: "Sigmoid" + input: "dense_out/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "Adam/iterations/Initializer/initial_value" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/iterations" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 0 + } + } + } + } + node { + name: "Adam/iterations" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/iterations" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "Adam/iterations" + } + } + } + node { + name: "Adam/iterations/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "Adam/iterations" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "Adam/iterations/Assign" + op: "AssignVariableOp" + input: "Adam/iterations" + input: "Adam/iterations/Initializer/initial_value" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/iterations" + } + } + } + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + } + node { + name: "Adam/iterations/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "Adam/iterations" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/iterations" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + } + node { + name: "Adam/lr/Initializer/initial_value" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/lr" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0010000000474974513 + } + } + } + } + node { + name: "Adam/lr" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/lr" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "Adam/lr" + } + } + } + node { + name: "Adam/lr/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "Adam/lr" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "Adam/lr/Assign" + op: "AssignVariableOp" + input: "Adam/lr" + input: "Adam/lr/Initializer/initial_value" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/lr" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "Adam/lr/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "Adam/lr" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/lr" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "Adam/beta_1/Initializer/initial_value" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/beta_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.8999999761581421 + } + } + } + } + node { + name: "Adam/beta_1" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/beta_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "Adam/beta_1" + } + } + } + node { + name: "Adam/beta_1/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "Adam/beta_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "Adam/beta_1/Assign" + op: "AssignVariableOp" + input: "Adam/beta_1" + input: "Adam/beta_1/Initializer/initial_value" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/beta_1" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "Adam/beta_1/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "Adam/beta_1" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/beta_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "Adam/beta_2/Initializer/initial_value" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/beta_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.9990000128746033 + } + } + } + } + node { + name: "Adam/beta_2" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/beta_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "Adam/beta_2" + } + } + } + node { + name: "Adam/beta_2/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "Adam/beta_2" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "Adam/beta_2/Assign" + op: "AssignVariableOp" + input: "Adam/beta_2" + input: "Adam/beta_2/Initializer/initial_value" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/beta_2" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "Adam/beta_2/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "Adam/beta_2" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/beta_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "Adam/decay/Initializer/initial_value" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/decay" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } + } + node { + name: "Adam/decay" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/decay" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "Adam/decay" + } + } + } + node { + name: "Adam/decay/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "Adam/decay" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "Adam/decay/Assign" + op: "AssignVariableOp" + input: "Adam/decay" + input: "Adam/decay/Initializer/initial_value" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/decay" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "Adam/decay/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "Adam/decay" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/decay" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "dense_out_target" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + node { + name: "Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 1.0 + } + } + } + } + node { + name: "dense_out_sample_weights" + op: "PlaceholderWithDefault" + input: "Const_1" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + } + } + } + } + node { + name: "total/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } + } + node { + name: "total" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "total" + } + } + } + node { + name: "total/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "total" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "total/Assign" + op: "AssignVariableOp" + input: "total" + input: "total/Initializer/zeros" + attr { + key: "_class" + value { + list { + s: "loc:@total" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "total/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "total" + attr { + key: "_class" + value { + list { + s: "loc:@total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "count/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } + } + node { + name: "count" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "count" + } + } + } + node { + name: "count/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "count" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "count/Assign" + op: "AssignVariableOp" + input: "count" + input: "count/Initializer/zeros" + attr { + key: "_class" + value { + list { + s: "loc:@count" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "count/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "count" + attr { + key: "_class" + value { + list { + s: "loc:@count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "total_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@total_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } + } + node { + name: "total_1" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@total_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "total_1" + } + } + } + node { + name: "total_1/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "total_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "total_1/Assign" + op: "AssignVariableOp" + input: "total_1" + input: "total_1/Initializer/zeros" + attr { + key: "_class" + value { + list { + s: "loc:@total_1" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "total_1/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "total_1" + attr { + key: "_class" + value { + list { + s: "loc:@total_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "count_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@count_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } + } + node { + name: "count_1" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@count_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "count_1" + } + } + } + node { + name: "count_1/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "count_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "count_1/Assign" + op: "AssignVariableOp" + input: "count_1" + input: "count_1/Initializer/zeros" + attr { + key: "_class" + value { + list { + s: "loc:@count_1" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "count_1/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "count_1" + attr { + key: "_class" + value { + list { + s: "loc:@count_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "loss/dense_out_loss/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0000000116860974e-07 + } + } + } + } + node { + name: "loss/dense_out_loss/sub/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } + } + node { + name: "loss/dense_out_loss/sub" + op: "Sub" + input: "loss/dense_out_loss/sub/x" + input: "loss/dense_out_loss/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/clip_by_value/Minimum" + op: "Minimum" + input: "dense_out/Sigmoid" + input: "loss/dense_out_loss/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/clip_by_value" + op: "Maximum" + input: "loss/dense_out_loss/clip_by_value/Minimum" + input: "loss/dense_out_loss/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/sub_1/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } + } + node { + name: "loss/dense_out_loss/sub_1" + op: "Sub" + input: "loss/dense_out_loss/sub_1/x" + input: "loss/dense_out_loss/clip_by_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/truediv" + op: "RealDiv" + input: "loss/dense_out_loss/clip_by_value" + input: "loss/dense_out_loss/sub_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/Log" + op: "Log" + input: "loss/dense_out_loss/truediv" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/logistic_loss/zeros_like" + op: "ZerosLike" + input: "loss/dense_out_loss/Log" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/logistic_loss/GreaterEqual" + op: "GreaterEqual" + input: "loss/dense_out_loss/Log" + input: "loss/dense_out_loss/logistic_loss/zeros_like" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/logistic_loss/Select" + op: "Select" + input: "loss/dense_out_loss/logistic_loss/GreaterEqual" + input: "loss/dense_out_loss/Log" + input: "loss/dense_out_loss/logistic_loss/zeros_like" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/logistic_loss/Neg" + op: "Neg" + input: "loss/dense_out_loss/Log" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/logistic_loss/Select_1" + op: "Select" + input: "loss/dense_out_loss/logistic_loss/GreaterEqual" + input: "loss/dense_out_loss/logistic_loss/Neg" + input: "loss/dense_out_loss/Log" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/logistic_loss/mul" + op: "Mul" + input: "loss/dense_out_loss/Log" + input: "dense_out_target" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/logistic_loss/sub" + op: "Sub" + input: "loss/dense_out_loss/logistic_loss/Select" + input: "loss/dense_out_loss/logistic_loss/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/logistic_loss/Exp" + op: "Exp" + input: "loss/dense_out_loss/logistic_loss/Select_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/logistic_loss/Log1p" + op: "Log1p" + input: "loss/dense_out_loss/logistic_loss/Exp" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/logistic_loss" + op: "Add" + input: "loss/dense_out_loss/logistic_loss/sub" + input: "loss/dense_out_loss/logistic_loss/Log1p" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/Mean/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } + } + node { + name: "loss/dense_out_loss/Mean" + op: "Mean" + input: "loss/dense_out_loss/logistic_loss" + input: "loss/dense_out_loss/Mean/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/weights/shape" + op: "Shape" + input: "dense_out_sample_weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/weights/rank" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/values/shape" + op: "Shape" + input: "loss/dense_out_loss/Mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/values/rank" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_scalar/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_scalar" + op: "Equal" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_scalar/x" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/weights/rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Switch" + op: "Switch" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_scalar" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_scalar" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/switch_t" + op: "Identity" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Switch:1" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/switch_f" + op: "Identity" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Switch" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id" + op: "Identity" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_scalar" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Switch_1" + op: "Switch" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_scalar" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_scalar" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank" + op: "Equal" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank/Switch" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank/Switch_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank/Switch" + op: "Switch" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/values/rank" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/dense_out_loss/broadcast_weights/assert_broadcastable/values/rank" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank/Switch_1" + op: "Switch" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/weights/rank" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/dense_out_loss/broadcast_weights/assert_broadcastable/weights/rank" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch" + op: "Switch" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t" + op: "Identity" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch:1" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_f" + op: "Identity" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id" + op: "Identity" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/dim" + op: "Const" + input: "^loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims" + op: "ExpandDims" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch_1:1" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/dim" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch" + op: "Switch" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/values/shape" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/dense_out_loss/broadcast_weights/assert_broadcastable/values/shape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + shape { + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch_1" + op: "Switch" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/dense_out_loss/broadcast_weights/assert_broadcastable/values/shape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + shape { + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like/Shape" + op: "Const" + input: "^loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like/Const" + op: "Const" + input: "^loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like" + op: "Fill" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like/Shape" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like/Const" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/concat/axis" + op: "Const" + input: "^loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/concat" + op: "ConcatV2" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 2 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/dim" + op: "Const" + input: "^loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1" + op: "ExpandDims" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch_1:1" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/dim" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch" + op: "Switch" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/weights/shape" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/dense_out_loss/broadcast_weights/assert_broadcastable/weights/shape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + shape { + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch_1" + op: "Switch" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/dense_out_loss/broadcast_weights/assert_broadcastable/weights/shape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + shape { + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/DenseToDenseSetOperation" + op: "DenseToDenseSetOperation" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/concat" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 2 + } + } + shape { + dim { + size: -1 + } + } + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "set_operation" + value { + s: "a-b" + } + } + attr { + key: "validate_indices" + value { + b: true + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/num_invalid_dims" + op: "Size" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/DenseToDenseSetOperation:1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/x" + op: "Const" + input: "^loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims" + op: "Equal" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/x" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/num_invalid_dims" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch_1" + op: "Switch" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Merge" + op: "Merge" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch_1" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Merge" + op: "Merge" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Merge" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Switch_1:1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "weights can not be broadcast to values." + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "weights.shape=" + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/Const_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "dense_out_sample_weights:0" + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/Const_3" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "values.shape=" + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/Const_4" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "loss/dense_out_loss/Mean:0" + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/Const_5" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "is_scalar=" + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Switch" + op: "Switch" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Merge" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Merge" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_t" + op: "Identity" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Switch:1" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f" + op: "Identity" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Switch" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id" + op: "Identity" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Merge" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/NoOp" + op: "NoOp" + input: "^loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_t" + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/control_dependency" + op: "Identity" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_t" + input: "^loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/NoOp" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_t" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_0" + op: "Const" + input: "^loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "weights can not be broadcast to values." + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_1" + op: "Const" + input: "^loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "weights.shape=" + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_2" + op: "Const" + input: "^loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "dense_out_sample_weights:0" + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_4" + op: "Const" + input: "^loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "values.shape=" + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_5" + op: "Const" + input: "^loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "loss/dense_out_loss/Mean:0" + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_7" + op: "Const" + input: "^loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "is_scalar=" + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert" + op: "Assert" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_0" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_1" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_2" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_1" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_4" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_5" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_2" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_7" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_3" + attr { + key: "T" + value { + list { + type: DT_STRING + type: DT_STRING + type: DT_STRING + type: DT_INT32 + type: DT_STRING + type: DT_STRING + type: DT_INT32 + type: DT_STRING + type: DT_BOOL + } + } + } + attr { + key: "summarize" + value { + i: 3 + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch" + op: "Switch" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Merge" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Merge" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_1" + op: "Switch" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/weights/shape" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/dense_out_loss/broadcast_weights/assert_broadcastable/weights/shape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + shape { + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_2" + op: "Switch" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/values/shape" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/dense_out_loss/broadcast_weights/assert_broadcastable/values/shape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + shape { + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_3" + op: "Switch" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_scalar" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_scalar" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/control_dependency_1" + op: "Identity" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f" + input: "^loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Merge" + op: "Merge" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/control_dependency_1" + input: "loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/ones_like/Shape" + op: "Shape" + input: "loss/dense_out_loss/Mean" + input: "^loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Merge" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/ones_like/Const" + op: "Const" + input: "^loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Merge" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights/ones_like" + op: "Fill" + input: "loss/dense_out_loss/broadcast_weights/ones_like/Shape" + input: "loss/dense_out_loss/broadcast_weights/ones_like/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } + } + node { + name: "loss/dense_out_loss/broadcast_weights" + op: "Mul" + input: "dense_out_sample_weights" + input: "loss/dense_out_loss/broadcast_weights/ones_like" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/Mul" + op: "Mul" + input: "loss/dense_out_loss/Mean" + input: "loss/dense_out_loss/broadcast_weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node { + name: "loss/dense_out_loss/Sum" + op: "Sum" + input: "loss/dense_out_loss/Mul" + input: "loss/dense_out_loss/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "loss/dense_out_loss/Const_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node { + name: "loss/dense_out_loss/Sum_1" + op: "Sum" + input: "loss/dense_out_loss/broadcast_weights" + input: "loss/dense_out_loss/Const_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "loss/dense_out_loss/div_no_nan" + op: "DivNoNan" + input: "loss/dense_out_loss/Sum" + input: "loss/dense_out_loss/Sum_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/dense_out_loss/Const_3" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } + } + node { + name: "loss/dense_out_loss/Mean_1" + op: "Mean" + input: "loss/dense_out_loss/div_no_nan" + input: "loss/dense_out_loss/Const_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "loss/mul/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } + } + node { + name: "loss/mul" + op: "Mul" + input: "loss/mul/x" + input: "loss/dense_out_loss/Mean_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/kernel/Regularizer/Square/ReadVariableOp" + op: "ReadVariableOp" + input: "dense_out/kernel" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "loss/kernel/Regularizer/Square" + op: "Square" + input: "loss/kernel/Regularizer/Square/ReadVariableOp" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/kernel/Regularizer/mul/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.10000000149011612 + } + } + } + } + node { + name: "loss/kernel/Regularizer/mul" + op: "Mul" + input: "loss/kernel/Regularizer/mul/x" + input: "loss/kernel/Regularizer/Square" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/kernel/Regularizer/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\000\000\000\000\001\000\000\000" + } + } + } + } + node { + name: "loss/kernel/Regularizer/Sum" + op: "Sum" + input: "loss/kernel/Regularizer/mul" + input: "loss/kernel/Regularizer/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "loss/kernel/Regularizer/add/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } + } + node { + name: "loss/kernel/Regularizer/add" + op: "Add" + input: "loss/kernel/Regularizer/add/x" + input: "loss/kernel/Regularizer/Sum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/add" + op: "Add" + input: "loss/mul" + input: "loss/kernel/Regularizer/add" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "metrics/acc/Cast/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } + } + node { + name: "metrics/acc/Greater" + op: "Greater" + input: "dense_out/Sigmoid" + input: "metrics/acc/Cast/x" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "metrics/acc/Cast_1" + op: "Cast" + input: "metrics/acc/Greater" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "Truncate" + value { + b: false + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "metrics/acc/Equal" + op: "Equal" + input: "dense_out_target" + input: "metrics/acc/Cast_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "metrics/acc/Cast_2" + op: "Cast" + input: "metrics/acc/Equal" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "Truncate" + value { + b: false + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "metrics/acc/Mean/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } + } + node { + name: "metrics/acc/Mean" + op: "Mean" + input: "metrics/acc/Cast_2" + input: "metrics/acc/Mean/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "metrics/acc/Size" + op: "Size" + input: "metrics/acc/Mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } + } + node { + name: "metrics/acc/Cast_3" + op: "Cast" + input: "metrics/acc/Size" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "Truncate" + value { + b: false + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "metrics/acc/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node { + name: "metrics/acc/Sum" + op: "Sum" + input: "metrics/acc/Mean" + input: "metrics/acc/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "metrics/acc/AssignAddVariableOp" + op: "AssignAddVariableOp" + input: "total" + input: "metrics/acc/Sum" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/acc/ReadVariableOp" + op: "ReadVariableOp" + input: "total" + input: "^metrics/acc/AssignAddVariableOp" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/acc/AssignAddVariableOp_1" + op: "AssignAddVariableOp" + input: "count" + input: "metrics/acc/Cast_3" + input: "^metrics/acc/ReadVariableOp" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/acc/ReadVariableOp_1" + op: "ReadVariableOp" + input: "count" + input: "^metrics/acc/AssignAddVariableOp_1" + input: "^metrics/acc/ReadVariableOp" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/acc/div_no_nan/ReadVariableOp" + op: "ReadVariableOp" + input: "total" + input: "^metrics/acc/ReadVariableOp_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/acc/div_no_nan/ReadVariableOp_1" + op: "ReadVariableOp" + input: "count" + input: "^metrics/acc/ReadVariableOp_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/acc/div_no_nan" + op: "DivNoNan" + input: "metrics/acc/div_no_nan/ReadVariableOp" + input: "metrics/acc/div_no_nan/ReadVariableOp_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "metrics/acc/Cast_4/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } + } + node { + name: "metrics/acc/Greater_1" + op: "Greater" + input: "dense_out/Sigmoid" + input: "metrics/acc/Cast_4/x" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "metrics/acc/Cast_5" + op: "Cast" + input: "metrics/acc/Greater_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "Truncate" + value { + b: false + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "metrics/acc/Equal_1" + op: "Equal" + input: "dense_out_target" + input: "metrics/acc/Cast_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "metrics/acc/Cast_6" + op: "Cast" + input: "metrics/acc/Equal_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "Truncate" + value { + b: false + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "metrics/acc/Mean_1/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } + } + node { + name: "metrics/acc/Mean_1" + op: "Mean" + input: "metrics/acc/Cast_6" + input: "metrics/acc/Mean_1/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "metrics/acc/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node { + name: "metrics/acc/Mean_2" + op: "Mean" + input: "metrics/acc/Mean_1" + input: "metrics/acc/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "metrics/mean_absolute_error/sub" + op: "Sub" + input: "dense_out/Sigmoid" + input: "dense_out_target" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "metrics/mean_absolute_error/Abs" + op: "Abs" + input: "metrics/mean_absolute_error/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "metrics/mean_absolute_error/Mean/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } + } + node { + name: "metrics/mean_absolute_error/Mean" + op: "Mean" + input: "metrics/mean_absolute_error/Abs" + input: "metrics/mean_absolute_error/Mean/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "metrics/mean_absolute_error/Size" + op: "Size" + input: "metrics/mean_absolute_error/Mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } + } + node { + name: "metrics/mean_absolute_error/Cast" + op: "Cast" + input: "metrics/mean_absolute_error/Size" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "Truncate" + value { + b: false + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "metrics/mean_absolute_error/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node { + name: "metrics/mean_absolute_error/Sum" + op: "Sum" + input: "metrics/mean_absolute_error/Mean" + input: "metrics/mean_absolute_error/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "metrics/mean_absolute_error/AssignAddVariableOp" + op: "AssignAddVariableOp" + input: "total_1" + input: "metrics/mean_absolute_error/Sum" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/mean_absolute_error/ReadVariableOp" + op: "ReadVariableOp" + input: "total_1" + input: "^metrics/mean_absolute_error/AssignAddVariableOp" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/mean_absolute_error/AssignAddVariableOp_1" + op: "AssignAddVariableOp" + input: "count_1" + input: "metrics/mean_absolute_error/Cast" + input: "^metrics/mean_absolute_error/ReadVariableOp" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/mean_absolute_error/ReadVariableOp_1" + op: "ReadVariableOp" + input: "count_1" + input: "^metrics/mean_absolute_error/AssignAddVariableOp_1" + input: "^metrics/mean_absolute_error/ReadVariableOp" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/mean_absolute_error/div_no_nan/ReadVariableOp" + op: "ReadVariableOp" + input: "total_1" + input: "^metrics/mean_absolute_error/ReadVariableOp_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/mean_absolute_error/div_no_nan/ReadVariableOp_1" + op: "ReadVariableOp" + input: "count_1" + input: "^metrics/mean_absolute_error/ReadVariableOp_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/mean_absolute_error/div_no_nan" + op: "DivNoNan" + input: "metrics/mean_absolute_error/div_no_nan/ReadVariableOp" + input: "metrics/mean_absolute_error/div_no_nan/ReadVariableOp_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "metrics/mean_absolute_error/sub_1" + op: "Sub" + input: "dense_out/Sigmoid" + input: "dense_out_target" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "metrics/mean_absolute_error/Abs_1" + op: "Abs" + input: "metrics/mean_absolute_error/sub_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "metrics/mean_absolute_error/Mean_1/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } + } + node { + name: "metrics/mean_absolute_error/Mean_1" + op: "Mean" + input: "metrics/mean_absolute_error/Abs_1" + input: "metrics/mean_absolute_error/Mean_1/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "metrics/mean_absolute_error/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node { + name: "metrics/mean_absolute_error/Mean_2" + op: "Mean" + input: "metrics/mean_absolute_error/Mean_1" + input: "metrics/mean_absolute_error/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "Placeholder" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + } + node { + name: "AssignVariableOp" + op: "AssignVariableOp" + input: "batch_norm/gamma" + input: "Placeholder" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "ReadVariableOp" + op: "ReadVariableOp" + input: "batch_norm/gamma" + input: "^AssignVariableOp" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "Placeholder_1" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + } + node { + name: "AssignVariableOp_1" + op: "AssignVariableOp" + input: "batch_norm/beta" + input: "Placeholder_1" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "ReadVariableOp_1" + op: "ReadVariableOp" + input: "batch_norm/beta" + input: "^AssignVariableOp_1" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "Placeholder_2" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + } + node { + name: "AssignVariableOp_2" + op: "AssignVariableOp" + input: "batch_norm/moving_mean" + input: "Placeholder_2" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "ReadVariableOp_2" + op: "ReadVariableOp" + input: "batch_norm/moving_mean" + input: "^AssignVariableOp_2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "Placeholder_3" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + } + node { + name: "AssignVariableOp_3" + op: "AssignVariableOp" + input: "batch_norm/moving_variance" + input: "Placeholder_3" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "ReadVariableOp_3" + op: "ReadVariableOp" + input: "batch_norm/moving_variance" + input: "^AssignVariableOp_3" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "Placeholder_4" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + node { + name: "AssignVariableOp_4" + op: "AssignVariableOp" + input: "dense_out/kernel" + input: "Placeholder_4" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "ReadVariableOp_4" + op: "ReadVariableOp" + input: "dense_out/kernel" + input: "^AssignVariableOp_4" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "Placeholder_5" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + } + node { + name: "AssignVariableOp_5" + op: "AssignVariableOp" + input: "dense_out/bias" + input: "Placeholder_5" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "ReadVariableOp_5" + op: "ReadVariableOp" + input: "dense_out/bias" + input: "^AssignVariableOp_5" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "Adam/beta_2" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_1" + op: "VarIsInitializedOp" + input: "count_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_2" + op: "VarIsInitializedOp" + input: "batch_norm/gamma" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_3" + op: "VarIsInitializedOp" + input: "batch_norm/moving_variance" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_4" + op: "VarIsInitializedOp" + input: "batch_norm/beta" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_5" + op: "VarIsInitializedOp" + input: "dense_out/kernel" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_6" + op: "VarIsInitializedOp" + input: "Adam/iterations" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_7" + op: "VarIsInitializedOp" + input: "total_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_8" + op: "VarIsInitializedOp" + input: "total" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_9" + op: "VarIsInitializedOp" + input: "Adam/beta_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_10" + op: "VarIsInitializedOp" + input: "Adam/lr" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_11" + op: "VarIsInitializedOp" + input: "batch_norm/moving_mean" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_12" + op: "VarIsInitializedOp" + input: "dense_out/bias" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_13" + op: "VarIsInitializedOp" + input: "count" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_14" + op: "VarIsInitializedOp" + input: "Adam/decay" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "init" + op: "NoOp" + input: "^Adam/beta_1/Assign" + input: "^Adam/beta_2/Assign" + input: "^Adam/decay/Assign" + input: "^Adam/iterations/Assign" + input: "^Adam/lr/Assign" + input: "^batch_norm/beta/Assign" + input: "^batch_norm/gamma/Assign" + input: "^batch_norm/moving_mean/Assign" + input: "^batch_norm/moving_variance/Assign" + input: "^count/Assign" + input: "^count_1/Assign" + input: "^dense_out/bias/Assign" + input: "^dense_out/kernel/Assign" + input: "^total/Assign" + input: "^total_1/Assign" + } + node { + name: "init_1" + op: "NoOp" + input: "^Adam/beta_1/Assign" + input: "^Adam/beta_2/Assign" + input: "^Adam/decay/Assign" + input: "^Adam/iterations/Assign" + input: "^Adam/lr/Assign" + input: "^batch_norm/beta/Assign" + input: "^batch_norm/gamma/Assign" + input: "^batch_norm/moving_mean/Assign" + input: "^batch_norm/moving_variance/Assign" + input: "^dense_out/bias/Assign" + input: "^dense_out/kernel/Assign" + } + node { + name: "init_2" + op: "NoOp" + } + node { + name: "group_deps" + op: "NoOp" + input: "^init_1" + input: "^init_2" + } + node { + name: "save/filename/input" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "model" + } + } + } + } + node { + name: "save/filename" + op: "PlaceholderWithDefault" + input: "save/filename/input" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "shape" + value { + shape { + } + } + } + } + node { + name: "save/Const" + op: "PlaceholderWithDefault" + input: "save/filename" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "shape" + value { + shape { + } + } + } + } + node { + name: "save/StringJoin/inputs_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "_temp_7f2179765c0043bba293f5b2b9e7ba06/part" + } + } + } + } + node { + name: "save/StringJoin" + op: "StringJoin" + input: "save/Const" + input: "save/StringJoin/inputs_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "separator" + value { + s: "" + } + } + } + node { + name: "save/num_shards" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "save/ShardedFilename/shard" + op: "Const" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } + } + node { + name: "save/ShardedFilename" + op: "ShardedFilename" + input: "save/StringJoin" + input: "save/ShardedFilename/shard" + input: "save/num_shards" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "save/SaveV2/tensor_names" + op: "Const" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 11 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 11 + } + } + string_val: "Adam/beta_1" + string_val: "Adam/beta_2" + string_val: "Adam/decay" + string_val: "Adam/iterations" + string_val: "Adam/lr" + string_val: "batch_norm/beta" + string_val: "batch_norm/gamma" + string_val: "batch_norm/moving_mean" + string_val: "batch_norm/moving_variance" + string_val: "dense_out/bias" + string_val: "dense_out/kernel" + } + } + } + } + node { + name: "save/SaveV2/shape_and_slices" + op: "Const" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 11 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 11 + } + } + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + } + } + } + } + node { + name: "save/SaveV2" + op: "SaveV2" + input: "save/ShardedFilename" + input: "save/SaveV2/tensor_names" + input: "save/SaveV2/shape_and_slices" + input: "Adam/beta_1/Read/ReadVariableOp" + input: "Adam/beta_2/Read/ReadVariableOp" + input: "Adam/decay/Read/ReadVariableOp" + input: "Adam/iterations/Read/ReadVariableOp" + input: "Adam/lr/Read/ReadVariableOp" + input: "batch_norm/beta/Read/ReadVariableOp" + input: "batch_norm/gamma/Read/ReadVariableOp" + input: "batch_norm/moving_mean/Read/ReadVariableOp" + input: "batch_norm/moving_variance/Read/ReadVariableOp" + input: "dense_out/bias/Read/ReadVariableOp" + input: "dense_out/kernel/Read/ReadVariableOp" + device: "/device:CPU:0" + attr { + key: "dtypes" + value { + list { + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_INT64 + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + } + } + } + } + node { + name: "save/control_dependency" + op: "Identity" + input: "save/ShardedFilename" + input: "^save/SaveV2" + device: "/device:CPU:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_class" + value { + list { + s: "loc:@save/ShardedFilename" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "save/MergeV2Checkpoints/checkpoint_prefixes" + op: "Pack" + input: "save/ShardedFilename" + input: "^save/control_dependency" + device: "/device:CPU:0" + attr { + key: "N" + value { + i: 1 + } + } + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } + } + node { + name: "save/MergeV2Checkpoints" + op: "MergeV2Checkpoints" + input: "save/MergeV2Checkpoints/checkpoint_prefixes" + input: "save/Const" + device: "/device:CPU:0" + attr { + key: "delete_old_dirs" + value { + b: true + } + } + } + node { + name: "save/Identity" + op: "Identity" + input: "save/Const" + input: "^save/MergeV2Checkpoints" + input: "^save/control_dependency" + device: "/device:CPU:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "save/RestoreV2/tensor_names" + op: "Const" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 11 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 11 + } + } + string_val: "Adam/beta_1" + string_val: "Adam/beta_2" + string_val: "Adam/decay" + string_val: "Adam/iterations" + string_val: "Adam/lr" + string_val: "batch_norm/beta" + string_val: "batch_norm/gamma" + string_val: "batch_norm/moving_mean" + string_val: "batch_norm/moving_variance" + string_val: "dense_out/bias" + string_val: "dense_out/kernel" + } + } + } + } + node { + name: "save/RestoreV2/shape_and_slices" + op: "Const" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 11 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 11 + } + } + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + } + } + } + } + node { + name: "save/RestoreV2" + op: "RestoreV2" + input: "save/Const" + input: "save/RestoreV2/tensor_names" + input: "save/RestoreV2/shape_and_slices" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + } + } + } + attr { + key: "dtypes" + value { + list { + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_INT64 + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + } + } + } + } + node { + name: "save/Identity_1" + op: "Identity" + input: "save/RestoreV2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + } + node { + name: "save/AssignVariableOp" + op: "AssignVariableOp" + input: "Adam/beta_1" + input: "save/Identity_1" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "save/Identity_2" + op: "Identity" + input: "save/RestoreV2:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + } + node { + name: "save/AssignVariableOp_1" + op: "AssignVariableOp" + input: "Adam/beta_2" + input: "save/Identity_2" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "save/Identity_3" + op: "Identity" + input: "save/RestoreV2:2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + } + node { + name: "save/AssignVariableOp_2" + op: "AssignVariableOp" + input: "Adam/decay" + input: "save/Identity_3" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "save/Identity_4" + op: "Identity" + input: "save/RestoreV2:3" + attr { + key: "T" + value { + type: DT_INT64 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + } + node { + name: "save/AssignVariableOp_3" + op: "AssignVariableOp" + input: "Adam/iterations" + input: "save/Identity_4" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + } + node { + name: "save/Identity_5" + op: "Identity" + input: "save/RestoreV2:4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + } + node { + name: "save/AssignVariableOp_4" + op: "AssignVariableOp" + input: "Adam/lr" + input: "save/Identity_5" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "save/Identity_6" + op: "Identity" + input: "save/RestoreV2:5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + } + node { + name: "save/AssignVariableOp_5" + op: "AssignVariableOp" + input: "batch_norm/beta" + input: "save/Identity_6" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "save/Identity_7" + op: "Identity" + input: "save/RestoreV2:6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + } + node { + name: "save/AssignVariableOp_6" + op: "AssignVariableOp" + input: "batch_norm/gamma" + input: "save/Identity_7" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "save/Identity_8" + op: "Identity" + input: "save/RestoreV2:7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + } + node { + name: "save/AssignVariableOp_7" + op: "AssignVariableOp" + input: "batch_norm/moving_mean" + input: "save/Identity_8" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "save/Identity_9" + op: "Identity" + input: "save/RestoreV2:8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + } + node { + name: "save/AssignVariableOp_8" + op: "AssignVariableOp" + input: "batch_norm/moving_variance" + input: "save/Identity_9" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "save/Identity_10" + op: "Identity" + input: "save/RestoreV2:9" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + } + node { + name: "save/AssignVariableOp_9" + op: "AssignVariableOp" + input: "dense_out/bias" + input: "save/Identity_10" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "save/Identity_11" + op: "Identity" + input: "save/RestoreV2:10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + } + node { + name: "save/AssignVariableOp_10" + op: "AssignVariableOp" + input: "dense_out/kernel" + input: "save/Identity_11" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "save/restore_shard" + op: "NoOp" + input: "^save/AssignVariableOp" + input: "^save/AssignVariableOp_1" + input: "^save/AssignVariableOp_10" + input: "^save/AssignVariableOp_2" + input: "^save/AssignVariableOp_3" + input: "^save/AssignVariableOp_4" + input: "^save/AssignVariableOp_5" + input: "^save/AssignVariableOp_6" + input: "^save/AssignVariableOp_7" + input: "^save/AssignVariableOp_8" + input: "^save/AssignVariableOp_9" + } + node { + name: "save/restore_all" + op: "NoOp" + input: "^save/restore_shard" + } + versions { + producer: 27 + } + } + saver_def { + filename_tensor_name: "save/Const:0" + save_tensor_name: "save/Identity:0" + restore_op_name: "save/restore_all" + max_to_keep: 5 + sharded: true + keep_checkpoint_every_n_hours: 10000.0 + version: V2 + } + collection_def { + key: "cond_context" + value { + bytes_list { + value: "\nSloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/cond_text\022Sloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id:0\032Tloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/switch_t:0 \001*\355\005\nFloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_scalar:0\nTloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Switch_1:0\nTloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Switch_1:1\nSloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id:0\nTloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/switch_t:0\022\236\001\nFloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_scalar:0\022Tloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Switch_1:1\022\252\001\nSloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id:0\022Sloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id:0" + value: "\nUloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/cond_text_1\022Sloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id:0\032Tloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/switch_f:0*\270*\nkloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Merge:0\nkloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Merge:1\nlloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch:0\nlloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch:1\nnloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch_1:0\nnloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch_1:1\n\217\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/DenseToDenseSetOperation:0\n\217\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/DenseToDenseSetOperation:1\n\217\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/DenseToDenseSetOperation:2\n\210\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch:0\n\212\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch_1:1\n\205\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/dim:0\n\201\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims:0\n\212\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch:0\n\214\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch_1:1\n\207\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/dim:0\n\203\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1:0\n\202\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/concat/axis:0\n}loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/concat:0\n\207\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/num_invalid_dims:0\n\206\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like/Const:0\n\206\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like/Shape:0\n\200\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like:0\nxloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/x:0\nvloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims:0\nyloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank/Switch:0\n{loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank/Switch_1:0\nrloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank:0\nmloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id:0\nnloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_f:0\nnloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t:0\nSloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id:0\nTloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/switch_f:0\nHloss/dense_out_loss/broadcast_weights/assert_broadcastable/values/rank:0\nIloss/dense_out_loss/broadcast_weights/assert_broadcastable/values/shape:0\nIloss/dense_out_loss/broadcast_weights/assert_broadcastable/weights/rank:0\nJloss/dense_out_loss/broadcast_weights/assert_broadcastable/weights/shape:0\022\326\001\nIloss/dense_out_loss/broadcast_weights/assert_broadcastable/values/shape:0\022\210\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch:0\022\310\001\nIloss/dense_out_loss/broadcast_weights/assert_broadcastable/weights/rank:0\022{loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank/Switch_1:0\022\252\001\nSloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id:0\022Sloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id:0\022\305\001\nHloss/dense_out_loss/broadcast_weights/assert_broadcastable/values/rank:0\022yloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank/Switch:0\022\331\001\nJloss/dense_out_loss/broadcast_weights/assert_broadcastable/weights/shape:0\022\212\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch:02\267#\n\264#\nmloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/cond_text\022mloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id:0\032nloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t:0 \001*\341 \n\217\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/DenseToDenseSetOperation:0\n\217\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/DenseToDenseSetOperation:1\n\217\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/DenseToDenseSetOperation:2\n\210\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch:0\n\212\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch_1:1\n\205\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/dim:0\n\201\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims:0\n\212\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch:0\n\214\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch_1:1\n\207\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/dim:0\n\203\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1:0\n\202\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/concat/axis:0\n}loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/concat:0\n\207\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/num_invalid_dims:0\n\206\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like/Const:0\n\206\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like/Shape:0\n\200\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like:0\nxloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/x:0\nvloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims:0\nmloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id:0\nnloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t:0\nIloss/dense_out_loss/broadcast_weights/assert_broadcastable/values/shape:0\nJloss/dense_out_loss/broadcast_weights/assert_broadcastable/weights/shape:0\022\232\002\n\212\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch:0\022\212\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch:0\022\333\001\nJloss/dense_out_loss/broadcast_weights/assert_broadcastable/weights/shape:0\022\214\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch_1:1\022\330\001\nIloss/dense_out_loss/broadcast_weights/assert_broadcastable/values/shape:0\022\212\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch_1:1\022\226\002\n\210\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch:0\022\210\001loss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch:0\022\336\001\nmloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id:0\022mloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id:02\321\n\n\316\n\noloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/cond_text_1\022mloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id:0\032nloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_f:0*\373\007\nnloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch_1:0\nnloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch_1:1\nrloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank:0\nmloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id:0\nnloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_f:0\022\336\001\nmloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id:0\022mloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id:0\022\344\001\nrloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank:0\022nloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch_1:0" + value: "\nPloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/cond_text\022Ploss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id:0\032Qloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_t:0 \001*\251\003\n[loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/control_dependency:0\nPloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id:0\nQloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_t:0\022\244\001\nPloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id:0\022Ploss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id:0" + value: "\nRloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/cond_text_1\022Ploss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id:0\032Qloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f:0*\367\021\nVloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch:0\nXloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_1:0\nXloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_2:0\nXloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_3:0\nVloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_0:0\nVloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_1:0\nVloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_2:0\nVloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_4:0\nVloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_5:0\nVloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_7:0\n]loss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/control_dependency_1:0\nPloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id:0\nQloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f:0\nFloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_scalar:0\nQloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Merge:0\nIloss/dense_out_loss/broadcast_weights/assert_broadcastable/values/shape:0\nJloss/dense_out_loss/broadcast_weights/assert_broadcastable/weights/shape:0\022\244\001\nPloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id:0\022Ploss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id:0\022\246\001\nJloss/dense_out_loss/broadcast_weights/assert_broadcastable/weights/shape:0\022Xloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_1:0\022\245\001\nIloss/dense_out_loss/broadcast_weights/assert_broadcastable/values/shape:0\022Xloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_2:0\022\242\001\nFloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_scalar:0\022Xloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_3:0\022\253\001\nQloss/dense_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Merge:0\022Vloss/dense_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch:0" + } + } + } + collection_def { + key: "trainable_variables" + value { + bytes_list { + value: "\n\022batch_norm/gamma:0\022\027batch_norm/gamma/Assign\032&batch_norm/gamma/Read/ReadVariableOp:0(\0012#batch_norm/gamma/Initializer/ones:08\001" + value: "\n\021batch_norm/beta:0\022\026batch_norm/beta/Assign\032%batch_norm/beta/Read/ReadVariableOp:0(\0012#batch_norm/beta/Initializer/zeros:08\001" + value: "\n\022dense_out/kernel:0\022\027dense_out/kernel/Assign\032&dense_out/kernel/Read/ReadVariableOp:0(\0012/dense_out/kernel/Initializer/truncated_normal:08\001" + value: "\n\020dense_out/bias:0\022\025dense_out/bias/Assign\032$dense_out/bias/Read/ReadVariableOp:0(\0012\"dense_out/bias/Initializer/zeros:08\001" + value: "\n\021Adam/iterations:0\022\026Adam/iterations/Assign\032%Adam/iterations/Read/ReadVariableOp:0(\0012+Adam/iterations/Initializer/initial_value:08\001" + value: "\n\tAdam/lr:0\022\016Adam/lr/Assign\032\035Adam/lr/Read/ReadVariableOp:0(\0012#Adam/lr/Initializer/initial_value:08\001" + value: "\n\rAdam/beta_1:0\022\022Adam/beta_1/Assign\032!Adam/beta_1/Read/ReadVariableOp:0(\0012\'Adam/beta_1/Initializer/initial_value:08\001" + value: "\n\rAdam/beta_2:0\022\022Adam/beta_2/Assign\032!Adam/beta_2/Read/ReadVariableOp:0(\0012\'Adam/beta_2/Initializer/initial_value:08\001" + value: "\n\014Adam/decay:0\022\021Adam/decay/Assign\032 Adam/decay/Read/ReadVariableOp:0(\0012&Adam/decay/Initializer/initial_value:08\001" + } + } + } + collection_def { + key: "variables" + value { + bytes_list { + value: "\n\022batch_norm/gamma:0\022\027batch_norm/gamma/Assign\032&batch_norm/gamma/Read/ReadVariableOp:0(\0012#batch_norm/gamma/Initializer/ones:08\001" + value: "\n\021batch_norm/beta:0\022\026batch_norm/beta/Assign\032%batch_norm/beta/Read/ReadVariableOp:0(\0012#batch_norm/beta/Initializer/zeros:08\001" + value: "\n\030batch_norm/moving_mean:0\022\035batch_norm/moving_mean/Assign\032,batch_norm/moving_mean/Read/ReadVariableOp:0(\0012*batch_norm/moving_mean/Initializer/zeros:0" + value: "\n\034batch_norm/moving_variance:0\022!batch_norm/moving_variance/Assign\0320batch_norm/moving_variance/Read/ReadVariableOp:0(\0012-batch_norm/moving_variance/Initializer/ones:0" + value: "\n\022dense_out/kernel:0\022\027dense_out/kernel/Assign\032&dense_out/kernel/Read/ReadVariableOp:0(\0012/dense_out/kernel/Initializer/truncated_normal:08\001" + value: "\n\020dense_out/bias:0\022\025dense_out/bias/Assign\032$dense_out/bias/Read/ReadVariableOp:0(\0012\"dense_out/bias/Initializer/zeros:08\001" + value: "\n\021Adam/iterations:0\022\026Adam/iterations/Assign\032%Adam/iterations/Read/ReadVariableOp:0(\0012+Adam/iterations/Initializer/initial_value:08\001" + value: "\n\tAdam/lr:0\022\016Adam/lr/Assign\032\035Adam/lr/Read/ReadVariableOp:0(\0012#Adam/lr/Initializer/initial_value:08\001" + value: "\n\rAdam/beta_1:0\022\022Adam/beta_1/Assign\032!Adam/beta_1/Read/ReadVariableOp:0(\0012\'Adam/beta_1/Initializer/initial_value:08\001" + value: "\n\rAdam/beta_2:0\022\022Adam/beta_2/Assign\032!Adam/beta_2/Read/ReadVariableOp:0(\0012\'Adam/beta_2/Initializer/initial_value:08\001" + value: "\n\014Adam/decay:0\022\021Adam/decay/Assign\032 Adam/decay/Read/ReadVariableOp:0(\0012&Adam/decay/Initializer/initial_value:08\001" + } + } + } + signature_def { + key: "serving_default" + value { + inputs { + key: "input_embedding_product_slug" + value { + name: "input_embedding_product_slug:0" + dtype: DT_FLOAT + tensor_shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + inputs { + key: "input_embedding_user_guid" + value { + name: "input_embedding_user_guid:0" + dtype: DT_FLOAT + tensor_shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + outputs { + key: "output" + value { + name: "dense_out/Sigmoid:0" + dtype: DT_FLOAT + tensor_shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + method_name: "tensorflow/serving/predict" + } + } +} diff --git a/model-integration/src/test/models/tensorflow/external/Model_B/factorization_machine_v1/export/standard/variables/variables.data-00000-of-00001 b/model-integration/src/test/models/tensorflow/external/Model_B/factorization_machine_v1/export/standard/variables/variables.data-00000-of-00001 Binary files differnew file mode 100644 index 00000000000..9997691bd2c --- /dev/null +++ b/model-integration/src/test/models/tensorflow/external/Model_B/factorization_machine_v1/export/standard/variables/variables.data-00000-of-00001 diff --git a/model-integration/src/test/models/tensorflow/external/Model_B/factorization_machine_v1/export/standard/variables/variables.index b/model-integration/src/test/models/tensorflow/external/Model_B/factorization_machine_v1/export/standard/variables/variables.index Binary files differnew file mode 100644 index 00000000000..98e80e982a9 --- /dev/null +++ b/model-integration/src/test/models/tensorflow/external/Model_B/factorization_machine_v1/export/standard/variables/variables.index diff --git a/model-integration/src/test/models/tensorflow/external/Model_C/factorization_machine_v1/export/optimized/saved_model.pbtxt b/model-integration/src/test/models/tensorflow/external/Model_C/factorization_machine_v1/export/optimized/saved_model.pbtxt new file mode 100644 index 00000000000..4678d78fe68 --- /dev/null +++ b/model-integration/src/test/models/tensorflow/external/Model_C/factorization_machine_v1/export/optimized/saved_model.pbtxt @@ -0,0 +1,959 @@ +saved_model_schema_version: 1 +meta_graphs { + meta_info_def { + stripped_op_list { + op { + name: "Const" + output_arg { + name: "output" + type_attr: "dtype" + } + attr { + name: "value" + type: "tensor" + } + attr { + name: "dtype" + type: "type" + } + } + op { + name: "ExpandDims" + input_arg { + name: "input" + type_attr: "T" + } + input_arg { + name: "dim" + type_attr: "Tdim" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "T" + type: "type" + } + attr { + name: "Tdim" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + op { + name: "Maximum" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_INT64 + } + } + } + is_commutative: true + } + op { + name: "Mul" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_UINT8 + type: DT_INT8 + type: DT_UINT16 + type: DT_INT16 + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + is_commutative: true + } + op { + name: "Placeholder" + output_arg { + name: "output" + type_attr: "dtype" + } + attr { + name: "dtype" + type: "type" + } + attr { + name: "shape" + type: "shape" + default_value { + shape { + unknown_rank: true + } + } + } + } + op { + name: "PlaceholderWithDefault" + input_arg { + name: "input" + type_attr: "dtype" + } + output_arg { + name: "output" + type_attr: "dtype" + } + attr { + name: "dtype" + type: "type" + } + attr { + name: "shape" + type: "shape" + } + } + op { + name: "Rsqrt" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "Sigmoid" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "Square" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "Sum" + input_arg { + name: "input" + type_attr: "T" + } + input_arg { + name: "reduction_indices" + type_attr: "Tidx" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "keep_dims" + type: "bool" + default_value { + b: false + } + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_UINT8 + type: DT_INT16 + type: DT_INT8 + type: DT_COMPLEX64 + type: DT_INT64 + type: DT_QINT8 + type: DT_QUINT8 + type: DT_QINT32 + type: DT_BFLOAT16 + type: DT_UINT16 + type: DT_COMPLEX128 + type: DT_HALF + type: DT_UINT32 + type: DT_UINT64 + } + } + } + attr { + name: "Tidx" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + } + tags: "serve" + tensorflow_version: "1.13.1" + tensorflow_git_version: "b\'v1.13.1-0-g6612da8951\'" + } + graph_def { + node { + name: "keras_learning_phase/input" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_BOOL + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_BOOL + tensor_shape { + } + bool_val: false + } + } + } + } + node { + name: "keras_learning_phase" + op: "PlaceholderWithDefault" + input: "keras_learning_phase/input" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_BOOL + } + } + attr { + key: "shape" + value { + shape { + } + } + } + } + node { + name: "dot_0/l2_normalize/Maximum/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 9.999999960041972e-13 + } + } + } + } + node { + name: "dot_0/l2_normalize/Sum/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "input_embedding_user_guid" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + node { + name: "dot_0/l2_normalize/Square" + op: "Square" + input: "input_embedding_user_guid" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize/Sum" + op: "Sum" + input: "dot_0/l2_normalize/Square" + input: "dot_0/l2_normalize/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: true + } + } + } + node { + name: "dot_0/l2_normalize/Maximum" + op: "Maximum" + input: "dot_0/l2_normalize/Sum" + input: "dot_0/l2_normalize/Maximum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize/Rsqrt" + op: "Rsqrt" + input: "dot_0/l2_normalize/Maximum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize" + op: "Mul" + input: "input_embedding_user_guid" + input: "dot_0/l2_normalize/Rsqrt" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "input_embedding_product_slug" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1/Square" + op: "Square" + input: "input_embedding_product_slug" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1/Sum" + op: "Sum" + input: "dot_0/l2_normalize_1/Square" + input: "dot_0/l2_normalize/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: true + } + } + } + node { + name: "dot_0/l2_normalize_1/Maximum" + op: "Maximum" + input: "dot_0/l2_normalize_1/Sum" + input: "dot_0/l2_normalize/Maximum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1/Rsqrt" + op: "Rsqrt" + input: "dot_0/l2_normalize_1/Maximum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1" + op: "Mul" + input: "input_embedding_product_slug" + input: "dot_0/l2_normalize_1/Rsqrt" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/Mul" + op: "Mul" + input: "dot_0/l2_normalize" + input: "dot_0/l2_normalize_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/Sum" + op: "Sum" + input: "dot_0/Mul" + input: "dot_0/l2_normalize/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "dot_0/ExpandDims" + op: "ExpandDims" + input: "dot_0/Sum" + input: "dot_0/l2_normalize/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "sigmoid_out/Sigmoid" + op: "Sigmoid" + input: "dot_0/ExpandDims" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + versions { + } + } + signature_def { + key: "serving_default" + value { + inputs { + key: "input_embedding_product_slug" + value { + name: "input_embedding_product_slug:0" + dtype: DT_FLOAT + tensor_shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + inputs { + key: "input_embedding_user_guid" + value { + name: "input_embedding_user_guid:0" + dtype: DT_FLOAT + tensor_shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + outputs { + key: "output" + value { + name: "sigmoid_out/Sigmoid:0" + dtype: DT_FLOAT + tensor_shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + method_name: "tensorflow/serving/predict" + } + } +} diff --git a/model-integration/src/test/models/tensorflow/external/Model_C/factorization_machine_v1/export/standard/saved_model.pbtxt b/model-integration/src/test/models/tensorflow/external/Model_C/factorization_machine_v1/export/standard/saved_model.pbtxt new file mode 100644 index 00000000000..cad3db9d898 --- /dev/null +++ b/model-integration/src/test/models/tensorflow/external/Model_C/factorization_machine_v1/export/standard/saved_model.pbtxt @@ -0,0 +1,8622 @@ +saved_model_schema_version: 1 +meta_graphs { + meta_info_def { + stripped_op_list { + op { + name: "Abs" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_INT64 + } + } + } + } + op { + name: "Add" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_UINT8 + type: DT_INT8 + type: DT_INT16 + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + type: DT_STRING + } + } + } + } + op { + name: "Assert" + input_arg { + name: "condition" + type: DT_BOOL + } + input_arg { + name: "data" + type_list_attr: "T" + } + attr { + name: "T" + type: "list(type)" + has_minimum: true + minimum: 1 + } + attr { + name: "summarize" + type: "int" + default_value { + i: 3 + } + } + is_stateful: true + } + op { + name: "AssignAddVariableOp" + input_arg { + name: "resource" + type: DT_RESOURCE + } + input_arg { + name: "value" + type_attr: "dtype" + } + attr { + name: "dtype" + type: "type" + } + is_stateful: true + } + op { + name: "AssignVariableOp" + input_arg { + name: "resource" + type: DT_RESOURCE + } + input_arg { + name: "value" + type_attr: "dtype" + } + attr { + name: "dtype" + type: "type" + } + is_stateful: true + } + op { + name: "Cast" + input_arg { + name: "x" + type_attr: "SrcT" + } + output_arg { + name: "y" + type_attr: "DstT" + } + attr { + name: "SrcT" + type: "type" + } + attr { + name: "DstT" + type: "type" + } + attr { + name: "Truncate" + type: "bool" + default_value { + b: false + } + } + } + op { + name: "ConcatV2" + input_arg { + name: "values" + type_attr: "T" + number_attr: "N" + } + input_arg { + name: "axis" + type_attr: "Tidx" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "N" + type: "int" + has_minimum: true + minimum: 2 + } + attr { + name: "T" + type: "type" + } + attr { + name: "Tidx" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + op { + name: "Const" + output_arg { + name: "output" + type_attr: "dtype" + } + attr { + name: "value" + type: "tensor" + } + attr { + name: "dtype" + type: "type" + } + } + op { + name: "DenseToDenseSetOperation" + input_arg { + name: "set1" + type_attr: "T" + } + input_arg { + name: "set2" + type_attr: "T" + } + output_arg { + name: "result_indices" + type: DT_INT64 + } + output_arg { + name: "result_values" + type_attr: "T" + } + output_arg { + name: "result_shape" + type: DT_INT64 + } + attr { + name: "set_operation" + type: "string" + } + attr { + name: "validate_indices" + type: "bool" + default_value { + b: true + } + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_INT8 + type: DT_INT16 + type: DT_INT32 + type: DT_INT64 + type: DT_UINT8 + type: DT_UINT16 + type: DT_STRING + } + } + } + } + op { + name: "DivNoNan" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_FLOAT + type: DT_DOUBLE + } + } + } + } + op { + name: "Equal" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type: DT_BOOL + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_UINT8 + type: DT_INT8 + type: DT_INT16 + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_QUINT8 + type: DT_QINT8 + type: DT_QINT32 + type: DT_STRING + type: DT_BOOL + type: DT_COMPLEX128 + } + } + } + is_commutative: true + } + op { + name: "Exp" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "ExpandDims" + input_arg { + name: "input" + type_attr: "T" + } + input_arg { + name: "dim" + type_attr: "Tdim" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "T" + type: "type" + } + attr { + name: "Tdim" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + op { + name: "Fill" + input_arg { + name: "dims" + type_attr: "index_type" + } + input_arg { + name: "value" + type_attr: "T" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "T" + type: "type" + } + attr { + name: "index_type" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + op { + name: "Greater" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type: DT_BOOL + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_UINT8 + type: DT_INT16 + type: DT_INT8 + type: DT_INT64 + type: DT_BFLOAT16 + type: DT_UINT16 + type: DT_HALF + type: DT_UINT32 + type: DT_UINT64 + } + } + } + } + op { + name: "GreaterEqual" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type: DT_BOOL + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_UINT8 + type: DT_INT16 + type: DT_INT8 + type: DT_INT64 + type: DT_BFLOAT16 + type: DT_UINT16 + type: DT_HALF + type: DT_UINT32 + type: DT_UINT64 + } + } + } + } + op { + name: "Identity" + input_arg { + name: "input" + type_attr: "T" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "T" + type: "type" + } + } + op { + name: "Log" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "Log1p" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "Maximum" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_INT64 + } + } + } + is_commutative: true + } + op { + name: "Mean" + input_arg { + name: "input" + type_attr: "T" + } + input_arg { + name: "reduction_indices" + type_attr: "Tidx" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "keep_dims" + type: "bool" + default_value { + b: false + } + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_UINT8 + type: DT_INT16 + type: DT_INT8 + type: DT_COMPLEX64 + type: DT_INT64 + type: DT_QINT8 + type: DT_QUINT8 + type: DT_QINT32 + type: DT_BFLOAT16 + type: DT_UINT16 + type: DT_COMPLEX128 + type: DT_HALF + type: DT_UINT32 + type: DT_UINT64 + } + } + } + attr { + name: "Tidx" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + op { + name: "Merge" + input_arg { + name: "inputs" + type_attr: "T" + number_attr: "N" + } + output_arg { + name: "output" + type_attr: "T" + } + output_arg { + name: "value_index" + type: DT_INT32 + } + attr { + name: "T" + type: "type" + } + attr { + name: "N" + type: "int" + has_minimum: true + minimum: 1 + } + } + op { + name: "MergeV2Checkpoints" + input_arg { + name: "checkpoint_prefixes" + type: DT_STRING + } + input_arg { + name: "destination_prefix" + type: DT_STRING + } + attr { + name: "delete_old_dirs" + type: "bool" + default_value { + b: true + } + } + is_stateful: true + } + op { + name: "Minimum" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_INT64 + } + } + } + is_commutative: true + } + op { + name: "Mul" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_UINT8 + type: DT_INT8 + type: DT_UINT16 + type: DT_INT16 + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + is_commutative: true + } + op { + name: "Neg" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "NoOp" + } + op { + name: "Pack" + input_arg { + name: "values" + type_attr: "T" + number_attr: "N" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "N" + type: "int" + has_minimum: true + minimum: 1 + } + attr { + name: "T" + type: "type" + } + attr { + name: "axis" + type: "int" + default_value { + i: 0 + } + } + } + op { + name: "Placeholder" + output_arg { + name: "output" + type_attr: "dtype" + } + attr { + name: "dtype" + type: "type" + } + attr { + name: "shape" + type: "shape" + default_value { + shape { + unknown_rank: true + } + } + } + } + op { + name: "PlaceholderWithDefault" + input_arg { + name: "input" + type_attr: "dtype" + } + output_arg { + name: "output" + type_attr: "dtype" + } + attr { + name: "dtype" + type: "type" + } + attr { + name: "shape" + type: "shape" + } + } + op { + name: "ReadVariableOp" + input_arg { + name: "resource" + type: DT_RESOURCE + } + output_arg { + name: "value" + type_attr: "dtype" + } + attr { + name: "dtype" + type: "type" + } + is_stateful: true + } + op { + name: "RealDiv" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_UINT8 + type: DT_INT8 + type: DT_UINT16 + type: DT_INT16 + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "RestoreV2" + input_arg { + name: "prefix" + type: DT_STRING + } + input_arg { + name: "tensor_names" + type: DT_STRING + } + input_arg { + name: "shape_and_slices" + type: DT_STRING + } + output_arg { + name: "tensors" + type_list_attr: "dtypes" + } + attr { + name: "dtypes" + type: "list(type)" + has_minimum: true + minimum: 1 + } + is_stateful: true + } + op { + name: "Rsqrt" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "SaveV2" + input_arg { + name: "prefix" + type: DT_STRING + } + input_arg { + name: "tensor_names" + type: DT_STRING + } + input_arg { + name: "shape_and_slices" + type: DT_STRING + } + input_arg { + name: "tensors" + type_list_attr: "dtypes" + } + attr { + name: "dtypes" + type: "list(type)" + has_minimum: true + minimum: 1 + } + is_stateful: true + } + op { + name: "Select" + input_arg { + name: "condition" + type: DT_BOOL + } + input_arg { + name: "t" + type_attr: "T" + } + input_arg { + name: "e" + type_attr: "T" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "T" + type: "type" + } + } + op { + name: "Shape" + input_arg { + name: "input" + type_attr: "T" + } + output_arg { + name: "output" + type_attr: "out_type" + } + attr { + name: "T" + type: "type" + } + attr { + name: "out_type" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + op { + name: "ShardedFilename" + input_arg { + name: "basename" + type: DT_STRING + } + input_arg { + name: "shard" + type: DT_INT32 + } + input_arg { + name: "num_shards" + type: DT_INT32 + } + output_arg { + name: "filename" + type: DT_STRING + } + } + op { + name: "Sigmoid" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "Size" + input_arg { + name: "input" + type_attr: "T" + } + output_arg { + name: "output" + type_attr: "out_type" + } + attr { + name: "T" + type: "type" + } + attr { + name: "out_type" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + op { + name: "Square" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "StringJoin" + input_arg { + name: "inputs" + type: DT_STRING + number_attr: "N" + } + output_arg { + name: "output" + type: DT_STRING + } + attr { + name: "N" + type: "int" + has_minimum: true + minimum: 1 + } + attr { + name: "separator" + type: "string" + default_value { + s: "" + } + } + } + op { + name: "Sub" + input_arg { + name: "x" + type_attr: "T" + } + input_arg { + name: "y" + type_attr: "T" + } + output_arg { + name: "z" + type_attr: "T" + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_BFLOAT16 + type: DT_HALF + type: DT_FLOAT + type: DT_DOUBLE + type: DT_UINT8 + type: DT_INT8 + type: DT_UINT16 + type: DT_INT16 + type: DT_INT32 + type: DT_INT64 + type: DT_COMPLEX64 + type: DT_COMPLEX128 + } + } + } + } + op { + name: "Sum" + input_arg { + name: "input" + type_attr: "T" + } + input_arg { + name: "reduction_indices" + type_attr: "Tidx" + } + output_arg { + name: "output" + type_attr: "T" + } + attr { + name: "keep_dims" + type: "bool" + default_value { + b: false + } + } + attr { + name: "T" + type: "type" + allowed_values { + list { + type: DT_FLOAT + type: DT_DOUBLE + type: DT_INT32 + type: DT_UINT8 + type: DT_INT16 + type: DT_INT8 + type: DT_COMPLEX64 + type: DT_INT64 + type: DT_QINT8 + type: DT_QUINT8 + type: DT_QINT32 + type: DT_BFLOAT16 + type: DT_UINT16 + type: DT_COMPLEX128 + type: DT_HALF + type: DT_UINT32 + type: DT_UINT64 + } + } + } + attr { + name: "Tidx" + type: "type" + default_value { + type: DT_INT32 + } + allowed_values { + list { + type: DT_INT32 + type: DT_INT64 + } + } + } + } + op { + name: "Switch" + input_arg { + name: "data" + type_attr: "T" + } + input_arg { + name: "pred" + type: DT_BOOL + } + output_arg { + name: "output_false" + type_attr: "T" + } + output_arg { + name: "output_true" + type_attr: "T" + } + attr { + name: "T" + type: "type" + } + } + op { + name: "VarHandleOp" + output_arg { + name: "resource" + type: DT_RESOURCE + } + attr { + name: "container" + type: "string" + default_value { + s: "" + } + } + attr { + name: "shared_name" + type: "string" + default_value { + s: "" + } + } + attr { + name: "dtype" + type: "type" + } + attr { + name: "shape" + type: "shape" + } + is_stateful: true + } + op { + name: "VarIsInitializedOp" + input_arg { + name: "resource" + type: DT_RESOURCE + } + output_arg { + name: "is_initialized" + type: DT_BOOL + } + is_stateful: true + } + op { + name: "ZerosLike" + input_arg { + name: "x" + type_attr: "T" + } + output_arg { + name: "y" + type_attr: "T" + } + attr { + name: "T" + type: "type" + } + } + } + tags: "serve" + tensorflow_version: "1.13.1" + tensorflow_git_version: "b\'v1.13.1-0-g6612da8951\'" + } + graph_def { + node { + name: "keras_learning_phase/input" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_BOOL + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_BOOL + tensor_shape { + } + bool_val: false + } + } + } + } + node { + name: "keras_learning_phase" + op: "PlaceholderWithDefault" + input: "keras_learning_phase/input" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_BOOL + } + } + attr { + key: "shape" + value { + shape { + } + } + } + } + node { + name: "input_embedding_user_guid" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + node { + name: "input_embedding_product_slug" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + node { + name: "dot_0/l2_normalize/Square" + op: "Square" + input: "input_embedding_user_guid" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize/Sum/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "dot_0/l2_normalize/Sum" + op: "Sum" + input: "dot_0/l2_normalize/Square" + input: "dot_0/l2_normalize/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: true + } + } + } + node { + name: "dot_0/l2_normalize/Maximum/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 9.999999960041972e-13 + } + } + } + } + node { + name: "dot_0/l2_normalize/Maximum" + op: "Maximum" + input: "dot_0/l2_normalize/Sum" + input: "dot_0/l2_normalize/Maximum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize/Rsqrt" + op: "Rsqrt" + input: "dot_0/l2_normalize/Maximum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize" + op: "Mul" + input: "input_embedding_user_guid" + input: "dot_0/l2_normalize/Rsqrt" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1/Square" + op: "Square" + input: "input_embedding_product_slug" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1/Sum/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "dot_0/l2_normalize_1/Sum" + op: "Sum" + input: "dot_0/l2_normalize_1/Square" + input: "dot_0/l2_normalize_1/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: true + } + } + } + node { + name: "dot_0/l2_normalize_1/Maximum/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 9.999999960041972e-13 + } + } + } + } + node { + name: "dot_0/l2_normalize_1/Maximum" + op: "Maximum" + input: "dot_0/l2_normalize_1/Sum" + input: "dot_0/l2_normalize_1/Maximum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1/Rsqrt" + op: "Rsqrt" + input: "dot_0/l2_normalize_1/Maximum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "dot_0/l2_normalize_1" + op: "Mul" + input: "input_embedding_product_slug" + input: "dot_0/l2_normalize_1/Rsqrt" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/Mul" + op: "Mul" + input: "dot_0/l2_normalize" + input: "dot_0/l2_normalize_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + } + } + node { + name: "dot_0/Sum/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "dot_0/Sum" + op: "Sum" + input: "dot_0/Mul" + input: "dot_0/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "dot_0/ExpandDims/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "dot_0/ExpandDims" + op: "ExpandDims" + input: "dot_0/Sum" + input: "dot_0/ExpandDims/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "sigmoid_out/Sigmoid" + op: "Sigmoid" + input: "dot_0/ExpandDims" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "Adam/iterations/Initializer/initial_value" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/iterations" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + } + int64_val: 0 + } + } + } + } + node { + name: "Adam/iterations" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/iterations" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "Adam/iterations" + } + } + } + node { + name: "Adam/iterations/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "Adam/iterations" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "Adam/iterations/Assign" + op: "AssignVariableOp" + input: "Adam/iterations" + input: "Adam/iterations/Initializer/initial_value" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/iterations" + } + } + } + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + } + node { + name: "Adam/iterations/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "Adam/iterations" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/iterations" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + } + node { + name: "Adam/lr/Initializer/initial_value" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/lr" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0010000000474974513 + } + } + } + } + node { + name: "Adam/lr" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/lr" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "Adam/lr" + } + } + } + node { + name: "Adam/lr/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "Adam/lr" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "Adam/lr/Assign" + op: "AssignVariableOp" + input: "Adam/lr" + input: "Adam/lr/Initializer/initial_value" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/lr" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "Adam/lr/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "Adam/lr" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/lr" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "Adam/beta_1/Initializer/initial_value" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/beta_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.8999999761581421 + } + } + } + } + node { + name: "Adam/beta_1" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/beta_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "Adam/beta_1" + } + } + } + node { + name: "Adam/beta_1/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "Adam/beta_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "Adam/beta_1/Assign" + op: "AssignVariableOp" + input: "Adam/beta_1" + input: "Adam/beta_1/Initializer/initial_value" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/beta_1" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "Adam/beta_1/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "Adam/beta_1" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/beta_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "Adam/beta_2/Initializer/initial_value" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/beta_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.9990000128746033 + } + } + } + } + node { + name: "Adam/beta_2" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/beta_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "Adam/beta_2" + } + } + } + node { + name: "Adam/beta_2/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "Adam/beta_2" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "Adam/beta_2/Assign" + op: "AssignVariableOp" + input: "Adam/beta_2" + input: "Adam/beta_2/Initializer/initial_value" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/beta_2" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "Adam/beta_2/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "Adam/beta_2" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/beta_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "Adam/decay/Initializer/initial_value" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/decay" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } + } + node { + name: "Adam/decay" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/decay" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "Adam/decay" + } + } + } + node { + name: "Adam/decay/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "Adam/decay" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "Adam/decay/Assign" + op: "AssignVariableOp" + input: "Adam/decay" + input: "Adam/decay/Initializer/initial_value" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/decay" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "Adam/decay/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "Adam/decay" + attr { + key: "_class" + value { + list { + s: "loc:@Adam/decay" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "sigmoid_out_target" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + node { + name: "Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 1.0 + } + } + } + } + node { + name: "sigmoid_out_sample_weights" + op: "PlaceholderWithDefault" + input: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + } + } + } + } + node { + name: "total/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } + } + node { + name: "total" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "total" + } + } + } + node { + name: "total/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "total" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "total/Assign" + op: "AssignVariableOp" + input: "total" + input: "total/Initializer/zeros" + attr { + key: "_class" + value { + list { + s: "loc:@total" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "total/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "total" + attr { + key: "_class" + value { + list { + s: "loc:@total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "count/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } + } + node { + name: "count" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "count" + } + } + } + node { + name: "count/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "count" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "count/Assign" + op: "AssignVariableOp" + input: "count" + input: "count/Initializer/zeros" + attr { + key: "_class" + value { + list { + s: "loc:@count" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "count/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "count" + attr { + key: "_class" + value { + list { + s: "loc:@count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "total_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@total_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } + } + node { + name: "total_1" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@total_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "total_1" + } + } + } + node { + name: "total_1/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "total_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "total_1/Assign" + op: "AssignVariableOp" + input: "total_1" + input: "total_1/Initializer/zeros" + attr { + key: "_class" + value { + list { + s: "loc:@total_1" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "total_1/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "total_1" + attr { + key: "_class" + value { + list { + s: "loc:@total_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "count_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@count_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } + } + node { + name: "count_1" + op: "VarHandleOp" + attr { + key: "_class" + value { + list { + s: "loc:@count_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "count_1" + } + } + } + node { + name: "count_1/IsInitialized/VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "count_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "count_1/Assign" + op: "AssignVariableOp" + input: "count_1" + input: "count_1/Initializer/zeros" + attr { + key: "_class" + value { + list { + s: "loc:@count_1" + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "count_1/Read/ReadVariableOp" + op: "ReadVariableOp" + input: "count_1" + attr { + key: "_class" + value { + list { + s: "loc:@count_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "loss/sigmoid_out_loss/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0000000116860974e-07 + } + } + } + } + node { + name: "loss/sigmoid_out_loss/sub/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } + } + node { + name: "loss/sigmoid_out_loss/sub" + op: "Sub" + input: "loss/sigmoid_out_loss/sub/x" + input: "loss/sigmoid_out_loss/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/clip_by_value/Minimum" + op: "Minimum" + input: "sigmoid_out/Sigmoid" + input: "loss/sigmoid_out_loss/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/clip_by_value" + op: "Maximum" + input: "loss/sigmoid_out_loss/clip_by_value/Minimum" + input: "loss/sigmoid_out_loss/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/sub_1/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } + } + node { + name: "loss/sigmoid_out_loss/sub_1" + op: "Sub" + input: "loss/sigmoid_out_loss/sub_1/x" + input: "loss/sigmoid_out_loss/clip_by_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/truediv" + op: "RealDiv" + input: "loss/sigmoid_out_loss/clip_by_value" + input: "loss/sigmoid_out_loss/sub_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/Log" + op: "Log" + input: "loss/sigmoid_out_loss/truediv" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/logistic_loss/zeros_like" + op: "ZerosLike" + input: "loss/sigmoid_out_loss/Log" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/logistic_loss/GreaterEqual" + op: "GreaterEqual" + input: "loss/sigmoid_out_loss/Log" + input: "loss/sigmoid_out_loss/logistic_loss/zeros_like" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/logistic_loss/Select" + op: "Select" + input: "loss/sigmoid_out_loss/logistic_loss/GreaterEqual" + input: "loss/sigmoid_out_loss/Log" + input: "loss/sigmoid_out_loss/logistic_loss/zeros_like" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/logistic_loss/Neg" + op: "Neg" + input: "loss/sigmoid_out_loss/Log" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/logistic_loss/Select_1" + op: "Select" + input: "loss/sigmoid_out_loss/logistic_loss/GreaterEqual" + input: "loss/sigmoid_out_loss/logistic_loss/Neg" + input: "loss/sigmoid_out_loss/Log" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/logistic_loss/mul" + op: "Mul" + input: "loss/sigmoid_out_loss/Log" + input: "sigmoid_out_target" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/logistic_loss/sub" + op: "Sub" + input: "loss/sigmoid_out_loss/logistic_loss/Select" + input: "loss/sigmoid_out_loss/logistic_loss/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/logistic_loss/Exp" + op: "Exp" + input: "loss/sigmoid_out_loss/logistic_loss/Select_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/logistic_loss/Log1p" + op: "Log1p" + input: "loss/sigmoid_out_loss/logistic_loss/Exp" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/logistic_loss" + op: "Add" + input: "loss/sigmoid_out_loss/logistic_loss/sub" + input: "loss/sigmoid_out_loss/logistic_loss/Log1p" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/Mean/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } + } + node { + name: "loss/sigmoid_out_loss/Mean" + op: "Mean" + input: "loss/sigmoid_out_loss/logistic_loss" + input: "loss/sigmoid_out_loss/Mean/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/weights/shape" + op: "Shape" + input: "sigmoid_out_sample_weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/weights/rank" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/values/shape" + op: "Shape" + input: "loss/sigmoid_out_loss/Mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/values/rank" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_scalar/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_scalar" + op: "Equal" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_scalar/x" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/weights/rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Switch" + op: "Switch" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_scalar" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_scalar" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/switch_t" + op: "Identity" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Switch:1" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/switch_f" + op: "Identity" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Switch" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id" + op: "Identity" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_scalar" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Switch_1" + op: "Switch" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_scalar" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_scalar" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank" + op: "Equal" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank/Switch" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank/Switch_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank/Switch" + op: "Switch" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/values/rank" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/values/rank" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank/Switch_1" + op: "Switch" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/weights/rank" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/weights/rank" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch" + op: "Switch" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t" + op: "Identity" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch:1" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_f" + op: "Identity" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id" + op: "Identity" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/dim" + op: "Const" + input: "^loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims" + op: "ExpandDims" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch_1:1" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/dim" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch" + op: "Switch" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/values/shape" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/values/shape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + shape { + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch_1" + op: "Switch" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/values/shape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + shape { + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like/Shape" + op: "Const" + input: "^loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like/Const" + op: "Const" + input: "^loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like" + op: "Fill" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like/Shape" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like/Const" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/concat/axis" + op: "Const" + input: "^loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/concat" + op: "ConcatV2" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 2 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/dim" + op: "Const" + input: "^loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1" + op: "ExpandDims" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch_1:1" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/dim" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch" + op: "Switch" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/weights/shape" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/weights/shape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + shape { + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch_1" + op: "Switch" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/weights/shape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + shape { + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/DenseToDenseSetOperation" + op: "DenseToDenseSetOperation" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/concat" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 2 + } + } + shape { + dim { + size: -1 + } + } + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "set_operation" + value { + s: "a-b" + } + } + attr { + key: "validate_indices" + value { + b: true + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/num_invalid_dims" + op: "Size" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/DenseToDenseSetOperation:1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/x" + op: "Const" + input: "^loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims" + op: "Equal" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/x" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/num_invalid_dims" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch_1" + op: "Switch" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Merge" + op: "Merge" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch_1" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Merge" + op: "Merge" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Merge" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Switch_1:1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "weights can not be broadcast to values." + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "weights.shape=" + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/Const_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "sigmoid_out_sample_weights:0" + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/Const_3" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "values.shape=" + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/Const_4" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "loss/sigmoid_out_loss/Mean:0" + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/Const_5" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "is_scalar=" + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Switch" + op: "Switch" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Merge" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Merge" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_t" + op: "Identity" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Switch:1" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f" + op: "Identity" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Switch" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id" + op: "Identity" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Merge" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/NoOp" + op: "NoOp" + input: "^loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_t" + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/control_dependency" + op: "Identity" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_t" + input: "^loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/NoOp" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_t" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_0" + op: "Const" + input: "^loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "weights can not be broadcast to values." + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_1" + op: "Const" + input: "^loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "weights.shape=" + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_2" + op: "Const" + input: "^loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "sigmoid_out_sample_weights:0" + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_4" + op: "Const" + input: "^loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "values.shape=" + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_5" + op: "Const" + input: "^loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "loss/sigmoid_out_loss/Mean:0" + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_7" + op: "Const" + input: "^loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "is_scalar=" + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert" + op: "Assert" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_0" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_1" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_2" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_1" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_4" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_5" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_2" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_7" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_3" + attr { + key: "T" + value { + list { + type: DT_STRING + type: DT_STRING + type: DT_STRING + type: DT_INT32 + type: DT_STRING + type: DT_STRING + type: DT_INT32 + type: DT_STRING + type: DT_BOOL + } + } + } + attr { + key: "summarize" + value { + i: 3 + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch" + op: "Switch" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Merge" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Merge" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_1" + op: "Switch" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/weights/shape" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/weights/shape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + shape { + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_2" + op: "Switch" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/values/shape" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/values/shape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + shape { + dim { + size: 1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_3" + op: "Switch" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_scalar" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_scalar" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/control_dependency_1" + op: "Identity" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f" + input: "^loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_class" + value { + list { + s: "loc:@loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Merge" + op: "Merge" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/control_dependency_1" + input: "loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/ones_like/Shape" + op: "Shape" + input: "loss/sigmoid_out_loss/Mean" + input: "^loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Merge" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/ones_like/Const" + op: "Const" + input: "^loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Merge" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights/ones_like" + op: "Fill" + input: "loss/sigmoid_out_loss/broadcast_weights/ones_like/Shape" + input: "loss/sigmoid_out_loss/broadcast_weights/ones_like/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } + } + node { + name: "loss/sigmoid_out_loss/broadcast_weights" + op: "Mul" + input: "sigmoid_out_sample_weights" + input: "loss/sigmoid_out_loss/broadcast_weights/ones_like" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/Mul" + op: "Mul" + input: "loss/sigmoid_out_loss/Mean" + input: "loss/sigmoid_out_loss/broadcast_weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node { + name: "loss/sigmoid_out_loss/Sum" + op: "Sum" + input: "loss/sigmoid_out_loss/Mul" + input: "loss/sigmoid_out_loss/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "loss/sigmoid_out_loss/Const_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node { + name: "loss/sigmoid_out_loss/Sum_1" + op: "Sum" + input: "loss/sigmoid_out_loss/broadcast_weights" + input: "loss/sigmoid_out_loss/Const_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "loss/sigmoid_out_loss/div_no_nan" + op: "DivNoNan" + input: "loss/sigmoid_out_loss/Sum" + input: "loss/sigmoid_out_loss/Sum_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/Const_3" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } + } + node { + name: "loss/sigmoid_out_loss/Mean_1" + op: "Mean" + input: "loss/sigmoid_out_loss/div_no_nan" + input: "loss/sigmoid_out_loss/Const_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "loss/mul/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } + } + node { + name: "loss/mul" + op: "Mul" + input: "loss/mul/x" + input: "loss/sigmoid_out_loss/Mean_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "metrics/acc/Cast/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } + } + node { + name: "metrics/acc/Greater" + op: "Greater" + input: "sigmoid_out/Sigmoid" + input: "metrics/acc/Cast/x" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "metrics/acc/Cast_1" + op: "Cast" + input: "metrics/acc/Greater" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "Truncate" + value { + b: false + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "metrics/acc/Equal" + op: "Equal" + input: "sigmoid_out_target" + input: "metrics/acc/Cast_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "metrics/acc/Cast_2" + op: "Cast" + input: "metrics/acc/Equal" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "Truncate" + value { + b: false + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "metrics/acc/Mean/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } + } + node { + name: "metrics/acc/Mean" + op: "Mean" + input: "metrics/acc/Cast_2" + input: "metrics/acc/Mean/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "metrics/acc/Size" + op: "Size" + input: "metrics/acc/Mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } + } + node { + name: "metrics/acc/Cast_3" + op: "Cast" + input: "metrics/acc/Size" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "Truncate" + value { + b: false + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "metrics/acc/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node { + name: "metrics/acc/Sum" + op: "Sum" + input: "metrics/acc/Mean" + input: "metrics/acc/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "metrics/acc/AssignAddVariableOp" + op: "AssignAddVariableOp" + input: "total" + input: "metrics/acc/Sum" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/acc/ReadVariableOp" + op: "ReadVariableOp" + input: "total" + input: "^metrics/acc/AssignAddVariableOp" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/acc/AssignAddVariableOp_1" + op: "AssignAddVariableOp" + input: "count" + input: "metrics/acc/Cast_3" + input: "^metrics/acc/ReadVariableOp" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/acc/ReadVariableOp_1" + op: "ReadVariableOp" + input: "count" + input: "^metrics/acc/AssignAddVariableOp_1" + input: "^metrics/acc/ReadVariableOp" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/acc/div_no_nan/ReadVariableOp" + op: "ReadVariableOp" + input: "total" + input: "^metrics/acc/ReadVariableOp_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/acc/div_no_nan/ReadVariableOp_1" + op: "ReadVariableOp" + input: "count" + input: "^metrics/acc/ReadVariableOp_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/acc/div_no_nan" + op: "DivNoNan" + input: "metrics/acc/div_no_nan/ReadVariableOp" + input: "metrics/acc/div_no_nan/ReadVariableOp_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "metrics/acc/Cast_4/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } + } + node { + name: "metrics/acc/Greater_1" + op: "Greater" + input: "sigmoid_out/Sigmoid" + input: "metrics/acc/Cast_4/x" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "metrics/acc/Cast_5" + op: "Cast" + input: "metrics/acc/Greater_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "Truncate" + value { + b: false + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } + } + node { + name: "metrics/acc/Equal_1" + op: "Equal" + input: "sigmoid_out_target" + input: "metrics/acc/Cast_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "metrics/acc/Cast_6" + op: "Cast" + input: "metrics/acc/Equal_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "Truncate" + value { + b: false + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "metrics/acc/Mean_1/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } + } + node { + name: "metrics/acc/Mean_1" + op: "Mean" + input: "metrics/acc/Cast_6" + input: "metrics/acc/Mean_1/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "metrics/acc/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node { + name: "metrics/acc/Mean_2" + op: "Mean" + input: "metrics/acc/Mean_1" + input: "metrics/acc/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "metrics/mean_absolute_error/sub" + op: "Sub" + input: "sigmoid_out/Sigmoid" + input: "sigmoid_out_target" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "metrics/mean_absolute_error/Abs" + op: "Abs" + input: "metrics/mean_absolute_error/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "metrics/mean_absolute_error/Mean/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } + } + node { + name: "metrics/mean_absolute_error/Mean" + op: "Mean" + input: "metrics/mean_absolute_error/Abs" + input: "metrics/mean_absolute_error/Mean/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "metrics/mean_absolute_error/Size" + op: "Size" + input: "metrics/mean_absolute_error/Mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } + } + node { + name: "metrics/mean_absolute_error/Cast" + op: "Cast" + input: "metrics/mean_absolute_error/Size" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "Truncate" + value { + b: false + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "metrics/mean_absolute_error/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node { + name: "metrics/mean_absolute_error/Sum" + op: "Sum" + input: "metrics/mean_absolute_error/Mean" + input: "metrics/mean_absolute_error/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "metrics/mean_absolute_error/AssignAddVariableOp" + op: "AssignAddVariableOp" + input: "total_1" + input: "metrics/mean_absolute_error/Sum" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/mean_absolute_error/ReadVariableOp" + op: "ReadVariableOp" + input: "total_1" + input: "^metrics/mean_absolute_error/AssignAddVariableOp" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/mean_absolute_error/AssignAddVariableOp_1" + op: "AssignAddVariableOp" + input: "count_1" + input: "metrics/mean_absolute_error/Cast" + input: "^metrics/mean_absolute_error/ReadVariableOp" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/mean_absolute_error/ReadVariableOp_1" + op: "ReadVariableOp" + input: "count_1" + input: "^metrics/mean_absolute_error/AssignAddVariableOp_1" + input: "^metrics/mean_absolute_error/ReadVariableOp" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/mean_absolute_error/div_no_nan/ReadVariableOp" + op: "ReadVariableOp" + input: "total_1" + input: "^metrics/mean_absolute_error/ReadVariableOp_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/mean_absolute_error/div_no_nan/ReadVariableOp_1" + op: "ReadVariableOp" + input: "count_1" + input: "^metrics/mean_absolute_error/ReadVariableOp_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "metrics/mean_absolute_error/div_no_nan" + op: "DivNoNan" + input: "metrics/mean_absolute_error/div_no_nan/ReadVariableOp" + input: "metrics/mean_absolute_error/div_no_nan/ReadVariableOp_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "metrics/mean_absolute_error/sub_1" + op: "Sub" + input: "sigmoid_out/Sigmoid" + input: "sigmoid_out_target" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "metrics/mean_absolute_error/Abs_1" + op: "Abs" + input: "metrics/mean_absolute_error/sub_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + } + node { + name: "metrics/mean_absolute_error/Mean_1/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } + } + node { + name: "metrics/mean_absolute_error/Mean_1" + op: "Mean" + input: "metrics/mean_absolute_error/Abs_1" + input: "metrics/mean_absolute_error/Mean_1/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "metrics/mean_absolute_error/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } + } + node { + name: "metrics/mean_absolute_error/Mean_2" + op: "Mean" + input: "metrics/mean_absolute_error/Mean_1" + input: "metrics/mean_absolute_error/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } + } + node { + name: "VarIsInitializedOp" + op: "VarIsInitializedOp" + input: "Adam/beta_2" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_1" + op: "VarIsInitializedOp" + input: "count_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_2" + op: "VarIsInitializedOp" + input: "Adam/decay" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_3" + op: "VarIsInitializedOp" + input: "total" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_4" + op: "VarIsInitializedOp" + input: "Adam/lr" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_5" + op: "VarIsInitializedOp" + input: "total_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_6" + op: "VarIsInitializedOp" + input: "count" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_7" + op: "VarIsInitializedOp" + input: "Adam/iterations" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "VarIsInitializedOp_8" + op: "VarIsInitializedOp" + input: "Adam/beta_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "init" + op: "NoOp" + input: "^Adam/beta_1/Assign" + input: "^Adam/beta_2/Assign" + input: "^Adam/decay/Assign" + input: "^Adam/iterations/Assign" + input: "^Adam/lr/Assign" + input: "^count/Assign" + input: "^count_1/Assign" + input: "^total/Assign" + input: "^total_1/Assign" + } + node { + name: "init_1" + op: "NoOp" + input: "^Adam/beta_1/Assign" + input: "^Adam/beta_2/Assign" + input: "^Adam/decay/Assign" + input: "^Adam/iterations/Assign" + input: "^Adam/lr/Assign" + } + node { + name: "init_2" + op: "NoOp" + } + node { + name: "group_deps" + op: "NoOp" + input: "^init_1" + input: "^init_2" + } + node { + name: "save/filename/input" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "model" + } + } + } + } + node { + name: "save/filename" + op: "PlaceholderWithDefault" + input: "save/filename/input" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "shape" + value { + shape { + } + } + } + } + node { + name: "save/Const" + op: "PlaceholderWithDefault" + input: "save/filename" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "shape" + value { + shape { + } + } + } + } + node { + name: "save/StringJoin/inputs_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "_temp_f9ee0bde57514bd8b273ce01b6ff32fd/part" + } + } + } + } + node { + name: "save/StringJoin" + op: "StringJoin" + input: "save/Const" + input: "save/StringJoin/inputs_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "separator" + value { + s: "" + } + } + } + node { + name: "save/num_shards" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } + } + node { + name: "save/ShardedFilename/shard" + op: "Const" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } + } + node { + name: "save/ShardedFilename" + op: "ShardedFilename" + input: "save/StringJoin" + input: "save/ShardedFilename/shard" + input: "save/num_shards" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "save/SaveV2/tensor_names" + op: "Const" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 5 + } + } + string_val: "Adam/beta_1" + string_val: "Adam/beta_2" + string_val: "Adam/decay" + string_val: "Adam/iterations" + string_val: "Adam/lr" + } + } + } + } + node { + name: "save/SaveV2/shape_and_slices" + op: "Const" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 5 + } + } + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + } + } + } + } + node { + name: "save/SaveV2" + op: "SaveV2" + input: "save/ShardedFilename" + input: "save/SaveV2/tensor_names" + input: "save/SaveV2/shape_and_slices" + input: "Adam/beta_1/Read/ReadVariableOp" + input: "Adam/beta_2/Read/ReadVariableOp" + input: "Adam/decay/Read/ReadVariableOp" + input: "Adam/iterations/Read/ReadVariableOp" + input: "Adam/lr/Read/ReadVariableOp" + device: "/device:CPU:0" + attr { + key: "dtypes" + value { + list { + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_INT64 + type: DT_FLOAT + } + } + } + } + node { + name: "save/control_dependency" + op: "Identity" + input: "save/ShardedFilename" + input: "^save/SaveV2" + device: "/device:CPU:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_class" + value { + list { + s: "loc:@save/ShardedFilename" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "save/MergeV2Checkpoints/checkpoint_prefixes" + op: "Pack" + input: "save/ShardedFilename" + input: "^save/control_dependency" + device: "/device:CPU:0" + attr { + key: "N" + value { + i: 1 + } + } + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } + } + node { + name: "save/MergeV2Checkpoints" + op: "MergeV2Checkpoints" + input: "save/MergeV2Checkpoints/checkpoint_prefixes" + input: "save/Const" + device: "/device:CPU:0" + attr { + key: "delete_old_dirs" + value { + b: true + } + } + } + node { + name: "save/Identity" + op: "Identity" + input: "save/Const" + input: "^save/MergeV2Checkpoints" + input: "^save/control_dependency" + device: "/device:CPU:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + } + node { + name: "save/RestoreV2/tensor_names" + op: "Const" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 5 + } + } + string_val: "Adam/beta_1" + string_val: "Adam/beta_2" + string_val: "Adam/decay" + string_val: "Adam/iterations" + string_val: "Adam/lr" + } + } + } + } + node { + name: "save/RestoreV2/shape_and_slices" + op: "Const" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 5 + } + } + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + } + } + } + } + node { + name: "save/RestoreV2" + op: "RestoreV2" + input: "save/Const" + input: "save/RestoreV2/tensor_names" + input: "save/RestoreV2/shape_and_slices" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + } + } + } + attr { + key: "dtypes" + value { + list { + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_INT64 + type: DT_FLOAT + } + } + } + } + node { + name: "save/Identity_1" + op: "Identity" + input: "save/RestoreV2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + } + node { + name: "save/AssignVariableOp" + op: "AssignVariableOp" + input: "Adam/beta_1" + input: "save/Identity_1" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "save/Identity_2" + op: "Identity" + input: "save/RestoreV2:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + } + node { + name: "save/AssignVariableOp_1" + op: "AssignVariableOp" + input: "Adam/beta_2" + input: "save/Identity_2" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "save/Identity_3" + op: "Identity" + input: "save/RestoreV2:2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + } + node { + name: "save/AssignVariableOp_2" + op: "AssignVariableOp" + input: "Adam/decay" + input: "save/Identity_3" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "save/Identity_4" + op: "Identity" + input: "save/RestoreV2:3" + attr { + key: "T" + value { + type: DT_INT64 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + } + node { + name: "save/AssignVariableOp_3" + op: "AssignVariableOp" + input: "Adam/iterations" + input: "save/Identity_4" + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + } + node { + name: "save/Identity_5" + op: "Identity" + input: "save/RestoreV2:4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + } + node { + name: "save/AssignVariableOp_4" + op: "AssignVariableOp" + input: "Adam/lr" + input: "save/Identity_5" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + } + node { + name: "save/restore_shard" + op: "NoOp" + input: "^save/AssignVariableOp" + input: "^save/AssignVariableOp_1" + input: "^save/AssignVariableOp_2" + input: "^save/AssignVariableOp_3" + input: "^save/AssignVariableOp_4" + } + node { + name: "save/restore_all" + op: "NoOp" + input: "^save/restore_shard" + } + versions { + producer: 27 + } + } + saver_def { + filename_tensor_name: "save/Const:0" + save_tensor_name: "save/Identity:0" + restore_op_name: "save/restore_all" + max_to_keep: 5 + sharded: true + keep_checkpoint_every_n_hours: 10000.0 + version: V2 + } + collection_def { + key: "cond_context" + value { + bytes_list { + value: "\nUloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/cond_text\022Uloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id:0\032Vloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/switch_t:0 \001*\377\005\nHloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_scalar:0\nVloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Switch_1:0\nVloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Switch_1:1\nUloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id:0\nVloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/switch_t:0\022\242\001\nHloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_scalar:0\022Vloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Switch_1:1\022\256\001\nUloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id:0\022Uloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id:0" + value: "\nWloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/cond_text_1\022Uloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id:0\032Vloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/switch_f:0*\226+\nmloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Merge:0\nmloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Merge:1\nnloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch:0\nnloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch:1\nploss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch_1:0\nploss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch_1:1\n\221\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/DenseToDenseSetOperation:0\n\221\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/DenseToDenseSetOperation:1\n\221\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/DenseToDenseSetOperation:2\n\212\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch:0\n\214\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch_1:1\n\207\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/dim:0\n\203\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims:0\n\214\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch:0\n\216\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch_1:1\n\211\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/dim:0\n\205\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1:0\n\204\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/concat/axis:0\n\177loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/concat:0\n\211\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/num_invalid_dims:0\n\210\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like/Const:0\n\210\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like/Shape:0\n\202\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like:0\nzloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/x:0\nxloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims:0\n{loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank/Switch:0\n}loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank/Switch_1:0\ntloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank:0\noloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id:0\nploss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_f:0\nploss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t:0\nUloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id:0\nVloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/switch_f:0\nJloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/values/rank:0\nKloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/values/shape:0\nKloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/weights/rank:0\nLloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/weights/shape:0\022\256\001\nUloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id:0\022Uloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/pred_id:0\022\332\001\nKloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/values/shape:0\022\212\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch:0\022\314\001\nKloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/weights/rank:0\022}loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank/Switch_1:0\022\335\001\nLloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/weights/shape:0\022\214\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch:0\022\311\001\nJloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/values/rank:0\022{loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank/Switch:02\377#\n\374#\noloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/cond_text\022oloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id:0\032ploss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t:0 \001*\243!\n\221\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/DenseToDenseSetOperation:0\n\221\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/DenseToDenseSetOperation:1\n\221\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/DenseToDenseSetOperation:2\n\212\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch:0\n\214\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch_1:1\n\207\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/dim:0\n\203\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims:0\n\214\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch:0\n\216\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch_1:1\n\211\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/dim:0\n\205\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1:0\n\204\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/concat/axis:0\n\177loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/concat:0\n\211\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/num_invalid_dims:0\n\210\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like/Const:0\n\210\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like/Shape:0\n\202\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ones_like:0\nzloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/x:0\nxloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims:0\noloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id:0\nploss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_t:0\nKloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/values/shape:0\nLloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/weights/shape:0\022\232\002\n\212\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch:0\022\212\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch:0\022\334\001\nKloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/values/shape:0\022\214\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims/Switch_1:1\022\342\001\noloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id:0\022oloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id:0\022\236\002\n\214\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch:0\022\214\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch:0\022\337\001\nLloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/weights/shape:0\022\216\001loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/has_invalid_dims/ExpandDims_1/Switch_1:12\351\n\n\346\n\nqloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/cond_text_1\022oloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id:0\032ploss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_f:0*\215\010\nploss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch_1:0\nploss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch_1:1\ntloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank:0\noloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id:0\nploss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/switch_f:0\022\350\001\ntloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/is_same_rank:0\022ploss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/Switch_1:0\022\342\001\noloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id:0\022oloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/has_valid_nonscalar_shape/pred_id:0" + value: "\nRloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/cond_text\022Rloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id:0\032Sloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_t:0 \001*\263\003\n]loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/control_dependency:0\nRloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id:0\nSloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_t:0\022\250\001\nRloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id:0\022Rloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id:0" + value: "\nTloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/cond_text_1\022Rloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id:0\032Sloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f:0*\255\022\nXloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch:0\nZloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_1:0\nZloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_2:0\nZloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_3:0\nXloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_0:0\nXloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_1:0\nXloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_2:0\nXloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_4:0\nXloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_5:0\nXloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/data_7:0\n_loss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/control_dependency_1:0\nRloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id:0\nSloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/switch_f:0\nHloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_scalar:0\nSloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Merge:0\nKloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/values/shape:0\nLloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/weights/shape:0\022\246\001\nHloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_scalar:0\022Zloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_3:0\022\251\001\nKloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/values/shape:0\022Zloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_2:0\022\257\001\nSloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/is_valid_shape/Merge:0\022Xloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch:0\022\250\001\nRloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id:0\022Rloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/pred_id:0\022\252\001\nLloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/weights/shape:0\022Zloss/sigmoid_out_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch_1:0" + } + } + } + collection_def { + key: "trainable_variables" + value { + bytes_list { + value: "\n\021Adam/iterations:0\022\026Adam/iterations/Assign\032%Adam/iterations/Read/ReadVariableOp:0(\0012+Adam/iterations/Initializer/initial_value:08\001" + value: "\n\tAdam/lr:0\022\016Adam/lr/Assign\032\035Adam/lr/Read/ReadVariableOp:0(\0012#Adam/lr/Initializer/initial_value:08\001" + value: "\n\rAdam/beta_1:0\022\022Adam/beta_1/Assign\032!Adam/beta_1/Read/ReadVariableOp:0(\0012\'Adam/beta_1/Initializer/initial_value:08\001" + value: "\n\rAdam/beta_2:0\022\022Adam/beta_2/Assign\032!Adam/beta_2/Read/ReadVariableOp:0(\0012\'Adam/beta_2/Initializer/initial_value:08\001" + value: "\n\014Adam/decay:0\022\021Adam/decay/Assign\032 Adam/decay/Read/ReadVariableOp:0(\0012&Adam/decay/Initializer/initial_value:08\001" + } + } + } + collection_def { + key: "variables" + value { + bytes_list { + value: "\n\021Adam/iterations:0\022\026Adam/iterations/Assign\032%Adam/iterations/Read/ReadVariableOp:0(\0012+Adam/iterations/Initializer/initial_value:08\001" + value: "\n\tAdam/lr:0\022\016Adam/lr/Assign\032\035Adam/lr/Read/ReadVariableOp:0(\0012#Adam/lr/Initializer/initial_value:08\001" + value: "\n\rAdam/beta_1:0\022\022Adam/beta_1/Assign\032!Adam/beta_1/Read/ReadVariableOp:0(\0012\'Adam/beta_1/Initializer/initial_value:08\001" + value: "\n\rAdam/beta_2:0\022\022Adam/beta_2/Assign\032!Adam/beta_2/Read/ReadVariableOp:0(\0012\'Adam/beta_2/Initializer/initial_value:08\001" + value: "\n\014Adam/decay:0\022\021Adam/decay/Assign\032 Adam/decay/Read/ReadVariableOp:0(\0012&Adam/decay/Initializer/initial_value:08\001" + } + } + } + signature_def { + key: "serving_default" + value { + inputs { + key: "input_embedding_product_slug" + value { + name: "input_embedding_user_guid:0" + dtype: DT_FLOAT + tensor_shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + inputs { + key: "input_embedding_user_guid" + value { + name: "input_embedding_product_slug:0" + dtype: DT_FLOAT + tensor_shape { + dim { + size: -1 + } + dim { + size: 32 + } + } + } + } + outputs { + key: "output" + value { + name: "sigmoid_out/Sigmoid:0" + dtype: DT_FLOAT + tensor_shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + method_name: "tensorflow/serving/predict" + } + } +} diff --git a/model-integration/src/test/models/tensorflow/external/Model_C/factorization_machine_v1/export/standard/variables/variables.data-00000-of-00001 b/model-integration/src/test/models/tensorflow/external/Model_C/factorization_machine_v1/export/standard/variables/variables.data-00000-of-00001 Binary files differnew file mode 100644 index 00000000000..8339979323b --- /dev/null +++ b/model-integration/src/test/models/tensorflow/external/Model_C/factorization_machine_v1/export/standard/variables/variables.data-00000-of-00001 diff --git a/model-integration/src/test/models/tensorflow/external/Model_C/factorization_machine_v1/export/standard/variables/variables.index b/model-integration/src/test/models/tensorflow/external/Model_C/factorization_machine_v1/export/standard/variables/variables.index Binary files differnew file mode 100644 index 00000000000..cf999e88e22 --- /dev/null +++ b/model-integration/src/test/models/tensorflow/external/Model_C/factorization_machine_v1/export/standard/variables/variables.index diff --git a/model-integration/src/test/models/tensorflow/external/modelv1/saved_model.pb b/model-integration/src/test/models/tensorflow/external/modelv1/saved_model.pb Binary files differnew file mode 100644 index 00000000000..223ad4baf59 --- /dev/null +++ b/model-integration/src/test/models/tensorflow/external/modelv1/saved_model.pb diff --git a/model-integration/src/test/models/tensorflow/external/modelv1/variables/variables.data-00000-of-00001 b/model-integration/src/test/models/tensorflow/external/modelv1/variables/variables.data-00000-of-00001 Binary files differnew file mode 100644 index 00000000000..76e3a429612 --- /dev/null +++ b/model-integration/src/test/models/tensorflow/external/modelv1/variables/variables.data-00000-of-00001 diff --git a/model-integration/src/test/models/tensorflow/external/modelv1/variables/variables.index b/model-integration/src/test/models/tensorflow/external/modelv1/variables/variables.index Binary files differnew file mode 100644 index 00000000000..285449d22c5 --- /dev/null +++ b/model-integration/src/test/models/tensorflow/external/modelv1/variables/variables.index diff --git a/model-integration/src/test/models/tensorflow/external/modelv2/saved_model.pb b/model-integration/src/test/models/tensorflow/external/modelv2/saved_model.pb Binary files differnew file mode 100644 index 00000000000..e2af4d90552 --- /dev/null +++ b/model-integration/src/test/models/tensorflow/external/modelv2/saved_model.pb diff --git a/model-integration/src/test/models/tensorflow/external/modelv2/variables/variables.data-00000-of-00001 b/model-integration/src/test/models/tensorflow/external/modelv2/variables/variables.data-00000-of-00001 Binary files differnew file mode 100644 index 00000000000..4bc7ff8a5d5 --- /dev/null +++ b/model-integration/src/test/models/tensorflow/external/modelv2/variables/variables.data-00000-of-00001 diff --git a/model-integration/src/test/models/tensorflow/external/modelv2/variables/variables.index b/model-integration/src/test/models/tensorflow/external/modelv2/variables/variables.index Binary files differnew file mode 100644 index 00000000000..398e369c5e3 --- /dev/null +++ b/model-integration/src/test/models/tensorflow/external/modelv2/variables/variables.index diff --git a/model-integration/src/test/models/tensorflow/external/train.py b/model-integration/src/test/models/tensorflow/external/train.py new file mode 100644 index 00000000000..b015f1ff5af --- /dev/null +++ b/model-integration/src/test/models/tensorflow/external/train.py @@ -0,0 +1,52 @@ +import numpy as np +import tensorflow as tf +import tensorflow.keras.backend as K + +from tensorflow.keras.layers import Input, Dense, concatenate +from tensorflow.keras.models import Model + +input_user = Input(shape=(3,)) +input_ad = Input(shape=(3,)) + +merged = concatenate([input_user, input_ad]) +output_1 = Dense(64, activation='relu')(merged) +output_2 = Dense(64, activation='relu')(output_1) +predictions = Dense(1)(output_2) + +model = Model(inputs=[input_user, input_ad], outputs=predictions) +model.compile(optimizer='adam', + loss='binary_crossentropy', + metrics=['accuracy']) +model.summary() + +SAMPLES = 1000 +user_data = np.random.rand(SAMPLES,3) +ad_data = np.random.rand(SAMPLES,3) +labels = np.random.rand(SAMPLES,1) +print(user_data[:10]) +print(ad_data[:10]) +print(labels[:10]) + +model.fit([user_data, ad_data], labels, epochs=10, ) # starts training + +user_data_sample1 = np.random.rand(1, 3) +ad_data_sample1 = np.random.rand(1, 3) + +print("predicting for:") +print(user_data_sample1) +print(ad_data_sample1) +predictions = model.predict([user_data_sample1, ad_data_sample1]) +print(predictions) + +signature = tf.saved_model.signature_def_utils.predict_signature_def( + inputs={'input1': model.inputs[0],'input2': model.inputs[1] }, outputs={'pctr': model.outputs[0]}) + +builder = tf.saved_model.builder.SavedModelBuilder('modelv1') +builder.add_meta_graph_and_variables( + sess=K.get_session(), + tags=[tf.saved_model.tag_constants.SERVING], + signature_def_map={ + tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY: + signature + }) +builder.save() diff --git a/model-integration/src/test/models/tensorflow/external/train_embed.py b/model-integration/src/test/models/tensorflow/external/train_embed.py new file mode 100644 index 00000000000..7aae61b49a7 --- /dev/null +++ b/model-integration/src/test/models/tensorflow/external/train_embed.py @@ -0,0 +1,65 @@ +import numpy as np +import tensorflow as tf +import tensorflow.keras.backend as K + +from tensorflow.keras.layers import Input, Dense, concatenate, Embedding, Reshape +from tensorflow.keras.models import Model + +input_user = Input(shape=(3,)) +input_ad = Input(shape=(3,)) +gender_samples = Input(shape=(1,), dtype='int32') + +gender_values = ['m', 'f', 'a'] + +gender_embeddings = Embedding(len(gender_values), 1)(gender_samples) +reshape_gender = Reshape(target_shape=[1])(gender_embeddings) + +model2 = Model(inputs=[gender_samples], outputs=reshape_gender) +model2.summary() + +merged = concatenate([input_user, input_ad, reshape_gender]) +output_1 = Dense(64, activation='relu')(merged) +output_2 = Dense(64, activation='relu')(output_1) +predictions = Dense(1)(output_2) + +model = Model(inputs=[input_user, input_ad, gender_samples], outputs=predictions) +model.compile(optimizer='adam', + loss='binary_crossentropy', + metrics=['accuracy']) +model.summary() + +SAMPLES = 1000 +user_data = np.random.rand(SAMPLES,3) +ad_data = np.random.rand(SAMPLES,3) +gender_data = np.random.randint(len(gender_values), size=SAMPLES) +labels = np.random.rand(SAMPLES,1) +print(user_data[:10]) +print(ad_data[:10]) +print(gender_data[:10]) +print(labels[:10]) + +model.fit([user_data, ad_data, gender_data], labels, epochs=10, ) # starts training + +user_data_sample1 = np.random.rand(1, 3) +ad_data_sample1 = np.random.rand(1, 3) +gender_data_sample1 = np.random.randint(len(gender_values), size=1) + +print("predicting for:") +print(user_data_sample1) +print(ad_data_sample1) +print(gender_data_sample1) +predictions = model.predict([user_data_sample1, ad_data_sample1, gender_data_sample1]) +print(predictions) + +signature = tf.saved_model.signature_def_utils.predict_signature_def( + inputs={'input1': model.inputs[0],'input2': model.inputs[1], 'input3': model.inputs[2] }, outputs={'pctrx': model.outputs[0]}) + +builder = tf.saved_model.builder.SavedModelBuilder('modelv2') +builder.add_meta_graph_and_variables( + sess=K.get_session(), + tags=[tf.saved_model.tag_constants.SERVING], + signature_def_map={ + tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY: + signature + }) +builder.save() |