diff --git a/examples/edge_intelligence/README.md b/examples/edge_intelligence/README.md new file mode 100755 index 00000000..1e456444 --- /dev/null +++ b/examples/edge_intelligence/README.md @@ -0,0 +1,34 @@ +# Edge Intelligence Models + +This folder contains [PFA](http://dmg.org/pfa/docs/motivation/), [scikit-learn](http://scikit-learn.org/) and [TensorFlow](https://www.tensorflow.org/) and RuleEdgeComponent examples. +Trained PFA, scikit-learn and TensorFlow models are present under the trained_models directory. +The generated data is using the [TI SensorTag](http://www.ti.com/ww/en/wireless_connectivity/sensortag/) which has been used for training the windmill model. +It provides a basic example which uses TI SensorTag data to simulate a sample windmill model. The basic metrics we collect from Windmill model using TI SensorTag are: + - RPM + - Vibration + - Ambient Temperature + - Relative Humidity. + +The files ```windmill_tf_train.csv``` and ```windmill_tf_test.csv``` in trained_models directory are used for training and testing of accuracy of the TensorFlow model respectively. +The file ```windmill_tf_model.py``` in trained_models directory is imdependent of Liota and used for creating the trained TensorFlow model and testing it's accuracy and prediction. + +# RuleEdgeComponent + +Rule edge component is one of the edge intelligence components provided by Liota, you can define a simple rule depending on your requirement as a [python lambda](https://www.python-course.eu/lambda.php) function and the rule edge component will process the incoming metrics and the result can be passed onto actuator on basis of the rule you have defined as lambda function. + +Currently tested for one metric only. + +# Example +If you have to take rpm as a metric and if rpm exceeds certain limits you have to perform some action, you can define a lambda function as: +``` +Rule = lambda rpm : 1 if (rpm>=rpm_limit) else 0 +``` +Now just create the ruleEdge and pass it onto RuleEdgeComponent along with the actuator_udm and exceed_limit. +actuator_udm can be used to pass on the value to the actuator, as of now we are printing them, here udm stands for user defined method. +exceed_limit is a parameter which can be specified about after how many times the limit is exceeded then action should be taken. +Example: If rpm exceeds rpm_limit consecutively exceed 3 times then only action should be applied, in that case we would assign exceed_limit = 3 +``` +edge_component = RuleEdgeComponent(ModelRule,exceed_limit,actuator_udm=action_actuator) +``` +After this register the edge_component and start_collecting the values from sensor. +The values which will get published to RuleEdge component. Please refer the example file windmill_graphite_rule.py. diff --git a/examples/edge_intelligence/trained_models/analytics_model.pfa b/examples/edge_intelligence/trained_models/analytics_model.pfa new file mode 100755 index 00000000..fd75886f --- /dev/null +++ b/examples/edge_intelligence/trained_models/analytics_model.pfa @@ -0,0 +1 @@ +{"@": "PrettyPFA document", "name": "Engine_1", "input": "double", "output": "double", "method": "map", "action": [{"@": "PrettyPFA line 14", "let": {"baseLL": {"@": "PrettyPFA line 14", "prob.dist.gaussianLL": ["input", {"@": "PrettyPFA line 14", "cell": "baseline", "path": [{"@": "PrettyPFA line 14", "string": "mu"}]}, {"@": "PrettyPFA line 14", "cell": "baseline", "path": [{"@": "PrettyPFA line 14", "string": "sig"}]}]}}}, {"@": "PrettyPFA line 15", "let": {"altLL": {"@": "PrettyPFA line 15", "prob.dist.gaussianLL": ["input", {"@": "PrettyPFA line 15", "cell": "alternate", "path": [{"@": "PrettyPFA line 15", "string": "mu"}]}, {"@": "PrettyPFA line 15", "cell": "alternate", "path": [{"@": "PrettyPFA line 15", "string": "sig"}]}]}}}, {"@": "PrettyPFA lines 16-17", "cell": "cusum", "to": {"params": [{"old": "double"}], "ret": "double", "do": [{"@": "PrettyPFA line 17", "stat.change.updateCUSUM": [{"@": "PrettyPFA line 17", "-": ["altLL", "baseLL"]}, "old", {"@": "PrettyPFA line 17", "cell": "reset"}]}]}}], "cells": {"cusum": {"@": "PrettyPFA line 8", "type": "double", "init": 0.0, "shared": true, "rollback": false}, "reset": {"@": "PrettyPFA line 9", "type": "double", "init": 0.0, "shared": false, "rollback": false}, "alternate": {"@": "PrettyPFA line 11", "type": {"fields": [{"type": "double", "name": "mu"}, {"type": "double", "name": "sig"}], "type": "record", "name": "Record_1"}, "init": {"mu": 24.23076923076923, "sig": 9.420276925706693}, "shared": false, "rollback": false}, "baseline": {"@": "PrettyPFA line 10", "type": "Record_1", "init": {"mu": 10.448598130841122, "sig": 2.0227690446443916}, "shared": false, "rollback": false}}} \ No newline at end of file diff --git a/examples/edge_intelligence/trained_models/sklearn_model.sav b/examples/edge_intelligence/trained_models/sklearn_model.sav new file mode 100755 index 00000000..39430345 Binary files /dev/null and b/examples/edge_intelligence/trained_models/sklearn_model.sav differ diff --git a/examples/edge_intelligence/trained_models/tensorflow_model/checkpoint b/examples/edge_intelligence/trained_models/tensorflow_model/checkpoint new file mode 100644 index 00000000..c19d2d35 --- /dev/null +++ b/examples/edge_intelligence/trained_models/tensorflow_model/checkpoint @@ -0,0 +1,3 @@ +model_checkpoint_path: "model.ckpt-2000" +all_model_checkpoint_paths: "model.ckpt-1" +all_model_checkpoint_paths: "model.ckpt-2000" diff --git a/examples/edge_intelligence/trained_models/tensorflow_model/events.out.tfevents.1502357622.ubuntu b/examples/edge_intelligence/trained_models/tensorflow_model/events.out.tfevents.1502357622.ubuntu new file mode 100644 index 00000000..62919453 Binary files /dev/null and b/examples/edge_intelligence/trained_models/tensorflow_model/events.out.tfevents.1502357622.ubuntu differ diff --git a/examples/edge_intelligence/trained_models/tensorflow_model/graph.pbtxt b/examples/edge_intelligence/trained_models/tensorflow_model/graph.pbtxt new file mode 100644 index 00000000..0dbeae5a --- /dev/null +++ b/examples/edge_intelligence/trained_models/tensorflow_model/graph.pbtxt @@ -0,0 +1,26388 @@ +node { + name: "global_step/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@global_step" + } + } + } + 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: "global_step" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@global_step" + } + } + } + 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: "" + } + } +} +node { + name: "global_step/Assign" + op: "Assign" + input: "global_step" + input: "global_step/Initializer/zeros" + attr { + key: "T" + value { + type: DT_INT64 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@global_step" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "global_step/read" + op: "Identity" + input: "global_step" + attr { + key: "T" + value { + type: DT_INT64 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@global_step" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + tensor_content: "\253\252\352@\000\000PAUUMA\000\0000AUU5A\000\0000AUU-A\253\252BA\253\252BAUUEAUUEAUU%A\000\000 AUUEA\253\252\032A\000\000HAUUEAUUMAUUEA\253\252JAUUMA\000\000HA\253\252RA\253\252JA\000\000`A\253\252RA\000\000PA\000\000pA\000\000pA\253\252\202A\000\000xA\000\000\200A\253\252rA\253\252\206A\253\252\206A\253\252\206AUU\205A\253\252\206AUU\201A\253\252\206A\000\000PAUUeA\000\000hAUU]AUUuA\000\000hA\000\000`AUUuA\000\000pA\253\252bA\000\000pAUUmAUUMAUU]AUU]A\253\252RAUU]A\253\252jA\000\000`A\000\000`A\000\000xA\000\000`A\000\000`AUU]AUUMA\000\000pA\000\0008A\253\252bA\253\252bAUUmAUUeAUUmA\253\252ZAUUeA\253\252bAUUUA\253\252ZAUU]AUUMAUUUAUU]A\253\252rA\000\000hA\000\000hA\000\000XA\253\252BA\000\000HAUUMAUUeA\253\252ZA\253\252bAUUeAUUUAUUUA\000\000`A\000\000PAUU]A\253\252RA\253\252RAUUMAUUUAUUUA\253\252ZA\253\252BAUU=A\000\000`A\253\252ZAUUUA\253\252ZAUUEAUUUA\000\000PAUUeA\253\252RAUU]A\000\000XAUUMAUUEA\253\252RA\000\000HA" + } + } + } +} +node { + name: "Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT64 + tensor_shape { + dim { + size: 120 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "linear//weight/part_0/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + 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: 0.0 + } + } + } +} +node { + name: "linear//weight/part_0" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + 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: "" + } + } +} +node { + name: "linear//weight/part_0/Assign" + op: "Assign" + input: "linear//weight/part_0" + input: "linear//weight/part_0/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear//weight/part_0/read" + op: "Identity" + input: "linear//weight/part_0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear//weight" + op: "Identity" + input: "linear//weight/part_0/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "matmul" + op: "MatMul" + input: "Const" + input: "linear//weight" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "linear/linear/Reshape/shape" + 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: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "linear/linear/Reshape" + op: "Reshape" + input: "matmul" + input: "linear/linear/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/bias_weight/part_0/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + 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: "linear/bias_weight/part_0" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + 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: "" + } + } +} +node { + name: "linear/bias_weight/part_0/Assign" + op: "Assign" + input: "linear/bias_weight/part_0" + input: "linear/bias_weight/part_0/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/bias_weight/part_0/read" + op: "Identity" + input: "linear/bias_weight/part_0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/bias_weight" + op: "Identity" + input: "linear/bias_weight/part_0/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/linear/BiasAdd" + op: "BiasAdd" + input: "linear/linear/Reshape" + input: "linear/bias_weight" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "linear/binary_logistic_head/predictions/zeros_like" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/predictions/concat/axis" + 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: "linear/binary_logistic_head/predictions/concat" + op: "ConcatV2" + input: "linear/binary_logistic_head/predictions/zeros_like" + input: "linear/linear/BiasAdd" + input: "linear/binary_logistic_head/predictions/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/predictions/logistic" + op: "Sigmoid" + input: "linear/linear/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/predictions/probabilities" + op: "Softmax" + input: "linear/binary_logistic_head/predictions/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/predictions/classes/dimension" + 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: "linear/binary_logistic_head/predictions/classes" + op: "ArgMax" + input: "linear/binary_logistic_head/predictions/concat" + input: "linear/binary_logistic_head/predictions/classes/dimension" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/log_loss_with_two_classes/ToFloat" + op: "Cast" + input: "Const_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT64 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/log_loss_with_two_classes/ExpandDims/dim" + 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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/log_loss_with_two_classes/ExpandDims" + op: "ExpandDims" + input: "linear/binary_logistic_head/log_loss_with_two_classes/ToFloat" + input: "linear/binary_logistic_head/log_loss_with_two_classes/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: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/log_loss_with_two_classes/zeros_like" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/log_loss_with_two_classes/GreaterEqual" + op: "GreaterEqual" + input: "linear/linear/BiasAdd" + input: "linear/binary_logistic_head/log_loss_with_two_classes/zeros_like" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/log_loss_with_two_classes/Select" + op: "Select" + input: "linear/binary_logistic_head/log_loss_with_two_classes/GreaterEqual" + input: "linear/linear/BiasAdd" + input: "linear/binary_logistic_head/log_loss_with_two_classes/zeros_like" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/log_loss_with_two_classes/Neg" + op: "Neg" + input: "linear/linear/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/log_loss_with_two_classes/Select_1" + op: "Select" + input: "linear/binary_logistic_head/log_loss_with_two_classes/GreaterEqual" + input: "linear/binary_logistic_head/log_loss_with_two_classes/Neg" + input: "linear/linear/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/log_loss_with_two_classes/mul" + op: "Mul" + input: "linear/linear/BiasAdd" + input: "linear/binary_logistic_head/log_loss_with_two_classes/ExpandDims" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/log_loss_with_two_classes/sub" + op: "Sub" + input: "linear/binary_logistic_head/log_loss_with_two_classes/Select" + input: "linear/binary_logistic_head/log_loss_with_two_classes/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/log_loss_with_two_classes/Exp" + op: "Exp" + input: "linear/binary_logistic_head/log_loss_with_two_classes/Select_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/log_loss_with_two_classes/Log1p" + op: "Log1p" + input: "linear/binary_logistic_head/log_loss_with_two_classes/Exp" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/log_loss_with_two_classes" + op: "Add" + input: "linear/binary_logistic_head/log_loss_with_two_classes/sub" + input: "linear/binary_logistic_head/log_loss_with_two_classes/Log1p" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/log_loss_with_two_classes/loss/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: "linear/binary_logistic_head/log_loss_with_two_classes/loss" + op: "Mean" + input: "linear/binary_logistic_head/log_loss_with_two_classes" + input: "linear/binary_logistic_head/log_loss_with_two_classes/loss/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: "linear/binary_logistic_head/ScalarSummary/tags" + 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" + } + } + } +} +node { + name: "linear/binary_logistic_head/ScalarSummary" + op: "ScalarSummary" + input: "linear/binary_logistic_head/ScalarSummary/tags" + input: "linear/binary_logistic_head/log_loss_with_two_classes/loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/Shape" + 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: "x\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/strided_slice/stack" + 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: "linear/binary_logistic_head/strided_slice/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/strided_slice/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/strided_slice" + op: "StridedSlice" + input: "linear/binary_logistic_head/Shape" + input: "linear/binary_logistic_head/strided_slice/stack" + input: "linear/binary_logistic_head/strided_slice/stack_1" + input: "linear/binary_logistic_head/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/Shape" + 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: "linear/binary_logistic_head/train_op/gradients/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.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/Fill" + op: "Fill" + input: "linear/binary_logistic_head/train_op/gradients/Shape" + input: "linear/binary_logistic_head/train_op/gradients/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Reshape/shape" + 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: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Reshape" + op: "Reshape" + input: "linear/binary_logistic_head/train_op/gradients/Fill" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Tile/multiples" + 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: "x\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Tile" + op: "Tile" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Reshape" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Tile/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Shape" + 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: "x\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Shape_1" + 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: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/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: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Prod" + op: "Prod" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Shape" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Const" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/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: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Prod_1" + op: "Prod" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Shape_1" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Const_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Maximum/y" + 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: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Maximum" + op: "Maximum" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Prod_1" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Maximum/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/floordiv" + op: "FloorDiv" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Prod" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Maximum" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Cast" + op: "Cast" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/floordiv" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/truediv" + op: "RealDiv" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Tile" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/Cast" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes_grad/Shape" + 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: "x\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes_grad/Shape_1" + 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: "x\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes_grad/Shape" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes_grad/Sum" + op: "Sum" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/truediv" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes_grad/Reshape" + op: "Reshape" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes_grad/Sum" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes_grad/Sum_1" + op: "Sum" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/loss_grad/truediv" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes_grad/Reshape_1" + op: "Reshape" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes_grad/Sum_1" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/Shape" + 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: "x\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/Shape_1" + 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: "x\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/Shape" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/Sum" + op: "Sum" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes_grad/Reshape" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/Reshape" + op: "Reshape" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/Sum" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/Sum_1" + op: "Sum" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes_grad/Reshape" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/Neg" + op: "Neg" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/Sum_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/Reshape_1" + op: "Reshape" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/Neg" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Log1p_grad/add/x" + op: "Const" + input: "^linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes_grad/Reshape_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: 1.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Log1p_grad/add" + op: "Add" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Log1p_grad/add/x" + input: "linear/binary_logistic_head/log_loss_with_two_classes/Exp" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Log1p_grad/Reciprocal" + op: "Reciprocal" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Log1p_grad/add" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Log1p_grad/mul" + op: "Mul" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes_grad/Reshape_1" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Log1p_grad/Reciprocal" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Select_grad/zeros_like" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Select_grad/Select" + op: "Select" + input: "linear/binary_logistic_head/log_loss_with_two_classes/GreaterEqual" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/Reshape" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Select_grad/zeros_like" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Select_grad/Select_1" + op: "Select" + input: "linear/binary_logistic_head/log_loss_with_two_classes/GreaterEqual" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Select_grad/zeros_like" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/Shape" + 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: "x\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/Shape_1" + 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: "x\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/Shape" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/mul" + op: "Mul" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/Reshape_1" + input: "linear/binary_logistic_head/log_loss_with_two_classes/ExpandDims" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/Sum" + op: "Sum" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/mul" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/Reshape" + op: "Reshape" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/Sum" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/mul_1" + op: "Mul" + input: "linear/linear/BiasAdd" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/sub_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/Sum_1" + op: "Sum" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/mul_1" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/Reshape_1" + op: "Reshape" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/Sum_1" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Exp_grad/mul" + op: "Mul" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Log1p_grad/mul" + input: "linear/binary_logistic_head/log_loss_with_two_classes/Exp" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Select_1_grad/zeros_like" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Select_1_grad/Select" + op: "Select" + input: "linear/binary_logistic_head/log_loss_with_two_classes/GreaterEqual" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Exp_grad/mul" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Select_1_grad/zeros_like" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Select_1_grad/Select_1" + op: "Select" + input: "linear/binary_logistic_head/log_loss_with_two_classes/GreaterEqual" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Select_1_grad/zeros_like" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Exp_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Neg_grad/Neg" + op: "Neg" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Select_1_grad/Select" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/AddN" + op: "AddN" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Select_grad/Select" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/mul_grad/Reshape" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Select_1_grad/Select_1" + input: "linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Neg_grad/Neg" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/train_op/gradients/linear/binary_logistic_head/log_loss_with_two_classes/Select_grad/Select" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/linear/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "linear/binary_logistic_head/train_op/gradients/AddN" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/linear/Reshape_grad/Shape" + 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: "x\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/linear/linear/Reshape_grad/Reshape" + op: "Reshape" + input: "linear/binary_logistic_head/train_op/gradients/AddN" + input: "linear/binary_logistic_head/train_op/gradients/linear/linear/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/matmul_grad/MatMul" + op: "MatMul" + input: "linear/binary_logistic_head/train_op/gradients/linear/linear/Reshape_grad/Reshape" + input: "linear//weight" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/train_op/gradients/matmul_grad/MatMul_1" + op: "MatMul" + input: "Const" + input: "linear/binary_logistic_head/train_op/gradients/linear/linear/Reshape_grad/Reshape" + 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: true + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/train_op/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + 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: 0.10000000149 + } + } + } +} +node { + name: "linear/binary_logistic_head/linear//weight/part_0/Ftrl" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/linear//weight/part_0/Ftrl/Assign" + op: "Assign" + input: "linear/binary_logistic_head/linear//weight/part_0/Ftrl" + input: "linear/binary_logistic_head/train_op/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/linear//weight/part_0/Ftrl/read" + op: "Identity" + input: "linear/binary_logistic_head/linear//weight/part_0/Ftrl" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/linear//weight/part_0/Ftrl_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + 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: 0.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/linear//weight/part_0/Ftrl_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/linear//weight/part_0/Ftrl_1/Assign" + op: "Assign" + input: "linear/binary_logistic_head/linear//weight/part_0/Ftrl_1" + input: "linear/binary_logistic_head/linear//weight/part_0/Ftrl_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/linear//weight/part_0/Ftrl_1/read" + op: "Identity" + input: "linear/binary_logistic_head/linear//weight/part_0/Ftrl_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/Const_1" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + 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.10000000149 + } + } + } +} +node { + name: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl/Assign" + op: "Assign" + input: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl" + input: "linear/binary_logistic_head/train_op/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl/read" + op: "Identity" + input: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + 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: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl_1/Assign" + op: "Assign" + input: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl_1" + input: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl_1/read" + op: "Identity" + input: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/Ftrl/learning_rate" + 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.20000000298 + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/Ftrl/l1_regularization_strength" + 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: "linear/binary_logistic_head/train_op/Ftrl/l2_regularization_strength" + 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: "linear/binary_logistic_head/train_op/Ftrl/learning_rate_power" + 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: "linear/binary_logistic_head/train_op/Ftrl/update_linear//weight/part_0/ApplyFtrl" + op: "ApplyFtrl" + input: "linear//weight/part_0" + input: "linear/binary_logistic_head/linear//weight/part_0/Ftrl" + input: "linear/binary_logistic_head/linear//weight/part_0/Ftrl_1" + input: "linear/binary_logistic_head/train_op/gradients/matmul_grad/MatMul_1" + input: "linear/binary_logistic_head/train_op/Ftrl/learning_rate" + input: "linear/binary_logistic_head/train_op/Ftrl/l1_regularization_strength" + input: "linear/binary_logistic_head/train_op/Ftrl/l2_regularization_strength" + input: "linear/binary_logistic_head/train_op/Ftrl/learning_rate_power" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/train_op/Ftrl/update_linear/bias_weight/part_0/ApplyFtrl" + op: "ApplyFtrl" + input: "linear/bias_weight/part_0" + input: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl" + input: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl_1" + input: "linear/binary_logistic_head/train_op/gradients/linear/linear/BiasAdd_grad/BiasAddGrad" + input: "linear/binary_logistic_head/train_op/Ftrl/learning_rate" + input: "linear/binary_logistic_head/train_op/Ftrl/l1_regularization_strength" + input: "linear/binary_logistic_head/train_op/Ftrl/l2_regularization_strength" + input: "linear/binary_logistic_head/train_op/Ftrl/learning_rate_power" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/train_op/Ftrl/update" + op: "NoOp" + input: "^linear/binary_logistic_head/train_op/Ftrl/update_linear//weight/part_0/ApplyFtrl" + input: "^linear/binary_logistic_head/train_op/Ftrl/update_linear/bias_weight/part_0/ApplyFtrl" +} +node { + name: "linear/binary_logistic_head/train_op/Ftrl/value" + op: "Const" + input: "^linear/binary_logistic_head/train_op/Ftrl/update" + attr { + key: "_class" + value { + list { + s: "loc:@global_step" + } + } + } + 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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/train_op/Ftrl" + op: "AssignAdd" + input: "global_step" + input: "linear/binary_logistic_head/train_op/Ftrl/value" + attr { + key: "T" + value { + type: DT_INT64 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@global_step" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean/zeros" + 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: "linear/binary_logistic_head/metrics/mean/total" + op: "VariableV2" + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean/total/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/mean/total" + input: "linear/binary_logistic_head/metrics/mean/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean/total/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/mean/total" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean/zeros_1" + 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: "linear/binary_logistic_head/metrics/mean/count" + op: "VariableV2" + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean/count/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/mean/count" + input: "linear/binary_logistic_head/metrics/mean/zeros_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean/count/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/mean/count" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean/Size" + 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: "linear/binary_logistic_head/metrics/mean/ToFloat_1" + op: "Cast" + input: "linear/binary_logistic_head/metrics/mean/Size" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean/Const" + 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: "linear/binary_logistic_head/metrics/mean/Sum" + op: "Sum" + input: "linear/binary_logistic_head/log_loss_with_two_classes/loss" + input: "linear/binary_logistic_head/metrics/mean/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: "linear/binary_logistic_head/metrics/mean/AssignAdd" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/mean/total" + input: "linear/binary_logistic_head/metrics/mean/Sum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean/AssignAdd_1" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/mean/count" + input: "linear/binary_logistic_head/metrics/mean/ToFloat_1" + input: "^linear/binary_logistic_head/log_loss_with_two_classes/loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean/Greater/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.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean/Greater" + op: "Greater" + input: "linear/binary_logistic_head/metrics/mean/count/read" + input: "linear/binary_logistic_head/metrics/mean/Greater/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean/truediv" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/mean/total/read" + input: "linear/binary_logistic_head/metrics/mean/count/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean/value/e" + 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: "linear/binary_logistic_head/metrics/mean/value" + op: "Select" + input: "linear/binary_logistic_head/metrics/mean/Greater" + input: "linear/binary_logistic_head/metrics/mean/truediv" + input: "linear/binary_logistic_head/metrics/mean/value/e" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean/Greater_1/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.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean/Greater_1" + op: "Greater" + input: "linear/binary_logistic_head/metrics/mean/AssignAdd_1" + input: "linear/binary_logistic_head/metrics/mean/Greater_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean/truediv_1" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/mean/AssignAdd" + input: "linear/binary_logistic_head/metrics/mean/AssignAdd_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean/update_op/e" + 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: "linear/binary_logistic_head/metrics/mean/update_op" + op: "Select" + input: "linear/binary_logistic_head/metrics/mean/Greater_1" + input: "linear/binary_logistic_head/metrics/mean/truediv_1" + input: "linear/binary_logistic_head/metrics/mean/update_op/e" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/Equal" + op: "Equal" + input: "linear/binary_logistic_head/predictions/classes" + input: "Const_1" + attr { + key: "T" + value { + type: DT_INT64 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/ToFloat" + op: "Cast" + input: "linear/binary_logistic_head/metrics/Equal" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy/zeros" + 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: "linear/binary_logistic_head/metrics/accuracy/total" + op: "VariableV2" + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy/total/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/accuracy/total" + input: "linear/binary_logistic_head/metrics/accuracy/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/accuracy/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy/total/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/accuracy/total" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/accuracy/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy/zeros_1" + 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: "linear/binary_logistic_head/metrics/accuracy/count" + op: "VariableV2" + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy/count/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/accuracy/count" + input: "linear/binary_logistic_head/metrics/accuracy/zeros_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/accuracy/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy/count/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/accuracy/count" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/accuracy/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy/Size" + 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: 120 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy/ToFloat_1" + op: "Cast" + input: "linear/binary_logistic_head/metrics/accuracy/Size" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy/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: "linear/binary_logistic_head/metrics/accuracy/Sum" + op: "Sum" + input: "linear/binary_logistic_head/metrics/ToFloat" + input: "linear/binary_logistic_head/metrics/accuracy/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: "linear/binary_logistic_head/metrics/accuracy/AssignAdd" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/accuracy/total" + input: "linear/binary_logistic_head/metrics/accuracy/Sum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/accuracy/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy/AssignAdd_1" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/accuracy/count" + input: "linear/binary_logistic_head/metrics/accuracy/ToFloat_1" + input: "^linear/binary_logistic_head/metrics/ToFloat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/accuracy/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy/Greater/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.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy/Greater" + op: "Greater" + input: "linear/binary_logistic_head/metrics/accuracy/count/read" + input: "linear/binary_logistic_head/metrics/accuracy/Greater/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy/truediv" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/accuracy/total/read" + input: "linear/binary_logistic_head/metrics/accuracy/count/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy/value/e" + 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: "linear/binary_logistic_head/metrics/accuracy/value" + op: "Select" + input: "linear/binary_logistic_head/metrics/accuracy/Greater" + input: "linear/binary_logistic_head/metrics/accuracy/truediv" + input: "linear/binary_logistic_head/metrics/accuracy/value/e" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy/Greater_1/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.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy/Greater_1" + op: "Greater" + input: "linear/binary_logistic_head/metrics/accuracy/AssignAdd_1" + input: "linear/binary_logistic_head/metrics/accuracy/Greater_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy/truediv_1" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/accuracy/AssignAdd" + input: "linear/binary_logistic_head/metrics/accuracy/AssignAdd_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy/update_op/e" + 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: "linear/binary_logistic_head/metrics/accuracy/update_op" + op: "Select" + input: "linear/binary_logistic_head/metrics/accuracy/Greater_1" + input: "linear/binary_logistic_head/metrics/accuracy/truediv_1" + input: "linear/binary_logistic_head/metrics/accuracy/update_op/e" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_1/zeros" + 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: "linear/binary_logistic_head/metrics/mean_1/total" + op: "VariableV2" + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_1/total/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/mean_1/total" + input: "linear/binary_logistic_head/metrics/mean_1/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_1/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_1/total/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/mean_1/total" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_1/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_1/zeros_1" + 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: "linear/binary_logistic_head/metrics/mean_1/count" + op: "VariableV2" + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_1/count/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/mean_1/count" + input: "linear/binary_logistic_head/metrics/mean_1/zeros_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_1/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_1/count/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/mean_1/count" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_1/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_1/Size" + 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: 120 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_1/ToFloat_1" + op: "Cast" + input: "linear/binary_logistic_head/metrics/mean_1/Size" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_1/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: "linear/binary_logistic_head/metrics/mean_1/Sum" + op: "Sum" + input: "linear/binary_logistic_head/predictions/logistic" + input: "linear/binary_logistic_head/metrics/mean_1/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: "linear/binary_logistic_head/metrics/mean_1/AssignAdd" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/mean_1/total" + input: "linear/binary_logistic_head/metrics/mean_1/Sum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_1/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_1/AssignAdd_1" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/mean_1/count" + input: "linear/binary_logistic_head/metrics/mean_1/ToFloat_1" + input: "^linear/binary_logistic_head/predictions/logistic" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_1/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_1/Greater/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.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_1/Greater" + op: "Greater" + input: "linear/binary_logistic_head/metrics/mean_1/count/read" + input: "linear/binary_logistic_head/metrics/mean_1/Greater/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_1/truediv" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/mean_1/total/read" + input: "linear/binary_logistic_head/metrics/mean_1/count/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_1/value/e" + 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: "linear/binary_logistic_head/metrics/mean_1/value" + op: "Select" + input: "linear/binary_logistic_head/metrics/mean_1/Greater" + input: "linear/binary_logistic_head/metrics/mean_1/truediv" + input: "linear/binary_logistic_head/metrics/mean_1/value/e" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_1/Greater_1/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.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_1/Greater_1" + op: "Greater" + input: "linear/binary_logistic_head/metrics/mean_1/AssignAdd_1" + input: "linear/binary_logistic_head/metrics/mean_1/Greater_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_1/truediv_1" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/mean_1/AssignAdd" + input: "linear/binary_logistic_head/metrics/mean_1/AssignAdd_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_1/update_op/e" + 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: "linear/binary_logistic_head/metrics/mean_1/update_op" + op: "Select" + input: "linear/binary_logistic_head/metrics/mean_1/Greater_1" + input: "linear/binary_logistic_head/metrics/mean_1/truediv_1" + input: "linear/binary_logistic_head/metrics/mean_1/update_op/e" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/ToFloat_2" + op: "Cast" + input: "Const_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT64 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_2/zeros" + 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: "linear/binary_logistic_head/metrics/mean_2/total" + op: "VariableV2" + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_2/total/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/mean_2/total" + input: "linear/binary_logistic_head/metrics/mean_2/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_2/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_2/total/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/mean_2/total" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_2/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_2/zeros_1" + 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: "linear/binary_logistic_head/metrics/mean_2/count" + op: "VariableV2" + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_2/count/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/mean_2/count" + input: "linear/binary_logistic_head/metrics/mean_2/zeros_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_2/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_2/count/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/mean_2/count" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_2/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_2/Size" + 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: 120 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_2/ToFloat_1" + op: "Cast" + input: "linear/binary_logistic_head/metrics/mean_2/Size" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_2/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: "linear/binary_logistic_head/metrics/mean_2/Sum" + op: "Sum" + input: "linear/binary_logistic_head/metrics/ToFloat_2" + input: "linear/binary_logistic_head/metrics/mean_2/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: "linear/binary_logistic_head/metrics/mean_2/AssignAdd" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/mean_2/total" + input: "linear/binary_logistic_head/metrics/mean_2/Sum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_2/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_2/AssignAdd_1" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/mean_2/count" + input: "linear/binary_logistic_head/metrics/mean_2/ToFloat_1" + input: "^linear/binary_logistic_head/metrics/ToFloat_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_2/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_2/Greater/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.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_2/Greater" + op: "Greater" + input: "linear/binary_logistic_head/metrics/mean_2/count/read" + input: "linear/binary_logistic_head/metrics/mean_2/Greater/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_2/truediv" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/mean_2/total/read" + input: "linear/binary_logistic_head/metrics/mean_2/count/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_2/value/e" + 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: "linear/binary_logistic_head/metrics/mean_2/value" + op: "Select" + input: "linear/binary_logistic_head/metrics/mean_2/Greater" + input: "linear/binary_logistic_head/metrics/mean_2/truediv" + input: "linear/binary_logistic_head/metrics/mean_2/value/e" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_2/Greater_1/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.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_2/Greater_1" + op: "Greater" + input: "linear/binary_logistic_head/metrics/mean_2/AssignAdd_1" + input: "linear/binary_logistic_head/metrics/mean_2/Greater_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_2/truediv_1" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/mean_2/AssignAdd" + input: "linear/binary_logistic_head/metrics/mean_2/AssignAdd_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_2/update_op/e" + 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: "linear/binary_logistic_head/metrics/mean_2/update_op" + op: "Select" + input: "linear/binary_logistic_head/metrics/mean_2/Greater_1" + input: "linear/binary_logistic_head/metrics/mean_2/truediv_1" + input: "linear/binary_logistic_head/metrics/mean_2/update_op/e" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/ToFloat_3" + op: "Cast" + input: "Const_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT64 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_3/zeros" + 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: "linear/binary_logistic_head/metrics/mean_3/total" + op: "VariableV2" + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_3/total/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/mean_3/total" + input: "linear/binary_logistic_head/metrics/mean_3/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_3/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_3/total/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/mean_3/total" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_3/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_3/zeros_1" + 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: "linear/binary_logistic_head/metrics/mean_3/count" + op: "VariableV2" + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_3/count/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/mean_3/count" + input: "linear/binary_logistic_head/metrics/mean_3/zeros_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_3/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_3/count/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/mean_3/count" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_3/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_3/Size" + 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: 120 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_3/ToFloat_1" + op: "Cast" + input: "linear/binary_logistic_head/metrics/mean_3/Size" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_3/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: "linear/binary_logistic_head/metrics/mean_3/Sum" + op: "Sum" + input: "linear/binary_logistic_head/metrics/ToFloat_3" + input: "linear/binary_logistic_head/metrics/mean_3/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: "linear/binary_logistic_head/metrics/mean_3/AssignAdd" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/mean_3/total" + input: "linear/binary_logistic_head/metrics/mean_3/Sum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_3/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_3/AssignAdd_1" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/mean_3/count" + input: "linear/binary_logistic_head/metrics/mean_3/ToFloat_1" + input: "^linear/binary_logistic_head/metrics/ToFloat_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_3/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_3/Greater/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.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_3/Greater" + op: "Greater" + input: "linear/binary_logistic_head/metrics/mean_3/count/read" + input: "linear/binary_logistic_head/metrics/mean_3/Greater/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_3/truediv" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/mean_3/total/read" + input: "linear/binary_logistic_head/metrics/mean_3/count/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_3/value/e" + 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: "linear/binary_logistic_head/metrics/mean_3/value" + op: "Select" + input: "linear/binary_logistic_head/metrics/mean_3/Greater" + input: "linear/binary_logistic_head/metrics/mean_3/truediv" + input: "linear/binary_logistic_head/metrics/mean_3/value/e" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_3/Greater_1/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.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_3/Greater_1" + op: "Greater" + input: "linear/binary_logistic_head/metrics/mean_3/AssignAdd_1" + input: "linear/binary_logistic_head/metrics/mean_3/Greater_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_3/truediv_1" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/mean_3/AssignAdd" + input: "linear/binary_logistic_head/metrics/mean_3/AssignAdd_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/mean_3/update_op/e" + 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: "linear/binary_logistic_head/metrics/mean_3/update_op" + op: "Select" + input: "linear/binary_logistic_head/metrics/mean_3/Greater_1" + input: "linear/binary_logistic_head/metrics/mean_3/truediv_1" + input: "linear/binary_logistic_head/metrics/mean_3/update_op/e" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/Cast" + op: "Cast" + input: "Const_1" + attr { + key: "DstT" + value { + type: DT_BOOL + } + } + attr { + key: "SrcT" + value { + type: DT_INT64 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/remove_squeezable_dimensions/Squeeze" + op: "Squeeze" + input: "linear/binary_logistic_head/predictions/logistic" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: -1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/Reshape/shape" + 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: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/Reshape" + op: "Reshape" + input: "linear/binary_logistic_head/metrics/auc/remove_squeezable_dimensions/Squeeze" + input: "linear/binary_logistic_head/metrics/auc/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/Reshape_1/shape" + 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: "\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/Reshape_1" + op: "Reshape" + input: "linear/binary_logistic_head/metrics/Cast" + input: "linear/binary_logistic_head/metrics/auc/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 200 + } + } + tensor_content: "\225\277\326\263\317\251\244;\317\251$<\267\376v<\317\251\244\370\311\005>G\357\n>\225\024\020>\3449\025>2_\032>\201\204\037>\317\251$>\036\317)>l\364.>\273\0314>\t?9>Wd>>\246\211C>\364\256H>C\324M>\221\371R>\340\036X>.D]>}ib>\313\216g>\032\264l>h\331q>\267\376v>\005$|>\252\244\200>Q7\203>\370\311\205>\240\\\210>G\357\212>\356\201\215>\225\024\220><\247\222>\3449\225>\213\314\227>2_\232>\331\361\234>\201\204\237>(\027\242>\317\251\244>v<\247>\036\317\251>\305a\254>l\364\256>\023\207\261>\273\031\264>b\254\266>\t?\271>\260\321\273>Wd\276>\377\366\300>\246\211\303>M\034\306>\364\256\310>\234A\313>C\324\315>\352f\320>\221\371\322>9\214\325>\340\036\330>\207\261\332>.D\335>\326\326\337>}i\342>$\374\344>\313\216\347>r!\352>\032\264\354>\301F\357>h\331\361>\017l\364>\267\376\366>^\221\371>\005$\374>\254\266\376>\252\244\000?\375\355\001?Q7\003?\245\200\004?\370\311\005?L\023\007?\240\\\010?\363\245\t?G\357\n?\2328\014?\356\201\r?B\313\016?\225\024\020?\351]\021?<\247\022?\220\360\023?\3449\025?7\203\026?\213\314\027?\337\025\031?2_\032?\206\250\033?\331\361\034?-;\036?\201\204\037?\324\315 ?(\027\"?{`#?\317\251$?#\363%?v<\'?\312\205(?\036\317)?q\030+?\305a,?\030\253-?l\364.?\300=0?\023\2071?g\3202?\273\0314?\016c5?b\2546?\265\3657?\t?9?]\210:?\260\321;?\004\033=?Wd>?\253\255??\377\366@?R@B?\246\211C?\372\322D?M\034F?\241eG?\364\256H?H\370I?\234AK?\357\212L?C\324M?\227\035O?\352fP?>\260Q?\221\371R?\345BT?9\214U?\214\325V?\340\036X?3hY?\207\261Z?\333\372[?.D]?\202\215^?\326\326_?) a?}ib?\320\262c?$\374d?xEf?\313\216g?\037\330h?r!j?\306jk?\032\264l?m\375m?\301Fo?\025\220p?h\331q?\274\"s?\017lt?c\265u?\267\376v?\nHx?^\221y?\262\332z?\005$|?Ym}?\254\266~?\001\000\200?" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/ExpandDims/dim" + 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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/ExpandDims" + op: "ExpandDims" + input: "linear/binary_logistic_head/metrics/auc/Const" + input: "linear/binary_logistic_head/metrics/auc/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: 200 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/stack" + 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: "\001\000\000\000x\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/Tile" + op: "Tile" + input: "linear/binary_logistic_head/metrics/auc/ExpandDims" + input: "linear/binary_logistic_head/metrics/auc/stack" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/transpose/Rank" + op: "Rank" + input: "linear/binary_logistic_head/metrics/auc/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/transpose/sub/y" + 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: "linear/binary_logistic_head/metrics/auc/transpose/sub" + op: "Sub" + input: "linear/binary_logistic_head/metrics/auc/transpose/Rank" + input: "linear/binary_logistic_head/metrics/auc/transpose/sub/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/transpose/Range/start" + 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: "linear/binary_logistic_head/metrics/auc/transpose/Range/delta" + 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: "linear/binary_logistic_head/metrics/auc/transpose/Range" + op: "Range" + input: "linear/binary_logistic_head/metrics/auc/transpose/Range/start" + input: "linear/binary_logistic_head/metrics/auc/transpose/Rank" + input: "linear/binary_logistic_head/metrics/auc/transpose/Range/delta" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/transpose/sub_1" + op: "Sub" + input: "linear/binary_logistic_head/metrics/auc/transpose/sub" + input: "linear/binary_logistic_head/metrics/auc/transpose/Range" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/transpose" + op: "Transpose" + input: "linear/binary_logistic_head/metrics/auc/Reshape" + input: "linear/binary_logistic_head/metrics/auc/transpose/sub_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/Tile_1/multiples" + 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: "\310\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/Tile_1" + op: "Tile" + input: "linear/binary_logistic_head/metrics/auc/transpose" + input: "linear/binary_logistic_head/metrics/auc/Tile_1/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/Greater" + op: "Greater" + input: "linear/binary_logistic_head/metrics/auc/Tile_1" + input: "linear/binary_logistic_head/metrics/auc/Tile" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/LogicalNot" + op: "LogicalNot" + input: "linear/binary_logistic_head/metrics/auc/Greater" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/Tile_2/multiples" + 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: "\310\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/Tile_2" + op: "Tile" + input: "linear/binary_logistic_head/metrics/auc/Reshape_1" + input: "linear/binary_logistic_head/metrics/auc/Tile_2/multiples" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/LogicalNot_1" + op: "LogicalNot" + input: "linear/binary_logistic_head/metrics/auc/Tile_2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/zeros" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 200 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/true_positives" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 200 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/true_positives/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/auc/true_positives" + input: "linear/binary_logistic_head/metrics/auc/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc/true_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/true_positives/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/auc/true_positives" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc/true_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/LogicalAnd" + op: "LogicalAnd" + input: "linear/binary_logistic_head/metrics/auc/Tile_2" + input: "linear/binary_logistic_head/metrics/auc/Greater" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/ToFloat_1" + op: "Cast" + input: "linear/binary_logistic_head/metrics/auc/LogicalAnd" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/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: "linear/binary_logistic_head/metrics/auc/Sum" + op: "Sum" + input: "linear/binary_logistic_head/metrics/auc/ToFloat_1" + input: "linear/binary_logistic_head/metrics/auc/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: 200 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/AssignAdd" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/auc/true_positives" + input: "linear/binary_logistic_head/metrics/auc/Sum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc/true_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/zeros_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 200 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/false_negatives" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 200 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/false_negatives/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/auc/false_negatives" + input: "linear/binary_logistic_head/metrics/auc/zeros_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc/false_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/false_negatives/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/auc/false_negatives" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc/false_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/LogicalAnd_1" + op: "LogicalAnd" + input: "linear/binary_logistic_head/metrics/auc/Tile_2" + input: "linear/binary_logistic_head/metrics/auc/LogicalNot" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/ToFloat_2" + op: "Cast" + input: "linear/binary_logistic_head/metrics/auc/LogicalAnd_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/Sum_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: "linear/binary_logistic_head/metrics/auc/Sum_1" + op: "Sum" + input: "linear/binary_logistic_head/metrics/auc/ToFloat_2" + input: "linear/binary_logistic_head/metrics/auc/Sum_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: 200 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/AssignAdd_1" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/auc/false_negatives" + input: "linear/binary_logistic_head/metrics/auc/Sum_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc/false_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/zeros_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 200 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/true_negatives" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 200 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/true_negatives/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/auc/true_negatives" + input: "linear/binary_logistic_head/metrics/auc/zeros_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc/true_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/true_negatives/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/auc/true_negatives" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc/true_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/LogicalAnd_2" + op: "LogicalAnd" + input: "linear/binary_logistic_head/metrics/auc/LogicalNot_1" + input: "linear/binary_logistic_head/metrics/auc/LogicalNot" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/ToFloat_3" + op: "Cast" + input: "linear/binary_logistic_head/metrics/auc/LogicalAnd_2" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/Sum_2/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: "linear/binary_logistic_head/metrics/auc/Sum_2" + op: "Sum" + input: "linear/binary_logistic_head/metrics/auc/ToFloat_3" + input: "linear/binary_logistic_head/metrics/auc/Sum_2/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: 200 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/AssignAdd_2" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/auc/true_negatives" + input: "linear/binary_logistic_head/metrics/auc/Sum_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc/true_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/zeros_3" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 200 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/false_positives" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 200 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/false_positives/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/auc/false_positives" + input: "linear/binary_logistic_head/metrics/auc/zeros_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc/false_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/false_positives/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/auc/false_positives" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc/false_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/LogicalAnd_3" + op: "LogicalAnd" + input: "linear/binary_logistic_head/metrics/auc/LogicalNot_1" + input: "linear/binary_logistic_head/metrics/auc/Greater" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/ToFloat_4" + op: "Cast" + input: "linear/binary_logistic_head/metrics/auc/LogicalAnd_3" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/Sum_3/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: "linear/binary_logistic_head/metrics/auc/Sum_3" + op: "Sum" + input: "linear/binary_logistic_head/metrics/auc/ToFloat_4" + input: "linear/binary_logistic_head/metrics/auc/Sum_3/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: 200 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/AssignAdd_3" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/auc/false_positives" + input: "linear/binary_logistic_head/metrics/auc/Sum_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc/false_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/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: 9.99999997475e-07 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/add" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc/true_positives/read" + input: "linear/binary_logistic_head/metrics/auc/add/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/add_1" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc/true_positives/read" + input: "linear/binary_logistic_head/metrics/auc/false_negatives/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/add_2/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.99999997475e-07 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/add_2" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc/add_1" + input: "linear/binary_logistic_head/metrics/auc/add_2/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/div" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/auc/add" + input: "linear/binary_logistic_head/metrics/auc/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/add_3" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc/false_positives/read" + input: "linear/binary_logistic_head/metrics/auc/true_negatives/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/add_4/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.99999997475e-07 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/add_4" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc/add_3" + input: "linear/binary_logistic_head/metrics/auc/add_4/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/div_1" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/auc/false_positives/read" + input: "linear/binary_logistic_head/metrics/auc/add_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice/stack" + 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: "linear/binary_logistic_head/metrics/auc/strided_slice/stack_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: 199 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice" + op: "StridedSlice" + input: "linear/binary_logistic_head/metrics/auc/div_1" + input: "linear/binary_logistic_head/metrics/auc/strided_slice/stack" + input: "linear/binary_logistic_head/metrics/auc/strided_slice/stack_1" + input: "linear/binary_logistic_head/metrics/auc/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_1/stack" + 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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_1/stack_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: "linear/binary_logistic_head/metrics/auc/strided_slice_1/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_1" + op: "StridedSlice" + input: "linear/binary_logistic_head/metrics/auc/div_1" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_1/stack" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_1/stack_1" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 1 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/sub" + op: "Sub" + input: "linear/binary_logistic_head/metrics/auc/strided_slice" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_2/stack" + 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: "linear/binary_logistic_head/metrics/auc/strided_slice_2/stack_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: 199 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_2/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_2" + op: "StridedSlice" + input: "linear/binary_logistic_head/metrics/auc/div" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_2/stack" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_2/stack_1" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_2/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_3/stack" + 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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_3/stack_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: "linear/binary_logistic_head/metrics/auc/strided_slice_3/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_3" + op: "StridedSlice" + input: "linear/binary_logistic_head/metrics/auc/div" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_3/stack" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_3/stack_1" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_3/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 1 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/add_5" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_2" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/truediv/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: 2.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/truediv" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/auc/add_5" + input: "linear/binary_logistic_head/metrics/auc/truediv/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/Mul" + op: "Mul" + input: "linear/binary_logistic_head/metrics/auc/sub" + input: "linear/binary_logistic_head/metrics/auc/truediv" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/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: "linear/binary_logistic_head/metrics/auc/value" + op: "Sum" + input: "linear/binary_logistic_head/metrics/auc/Mul" + input: "linear/binary_logistic_head/metrics/auc/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: "linear/binary_logistic_head/metrics/auc/add_6/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.99999997475e-07 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/add_6" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc/AssignAdd" + input: "linear/binary_logistic_head/metrics/auc/add_6/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/add_7" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc/AssignAdd" + input: "linear/binary_logistic_head/metrics/auc/AssignAdd_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/add_8/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.99999997475e-07 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/add_8" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc/add_7" + input: "linear/binary_logistic_head/metrics/auc/add_8/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/div_2" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/auc/add_6" + input: "linear/binary_logistic_head/metrics/auc/add_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/add_9" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc/AssignAdd_3" + input: "linear/binary_logistic_head/metrics/auc/AssignAdd_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/add_10/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.99999997475e-07 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/add_10" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc/add_9" + input: "linear/binary_logistic_head/metrics/auc/add_10/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/div_3" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/auc/AssignAdd_3" + input: "linear/binary_logistic_head/metrics/auc/add_10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_4/stack" + 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: "linear/binary_logistic_head/metrics/auc/strided_slice_4/stack_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: 199 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_4/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_4" + op: "StridedSlice" + input: "linear/binary_logistic_head/metrics/auc/div_3" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_4/stack" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_4/stack_1" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_4/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_5/stack" + 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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_5/stack_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: "linear/binary_logistic_head/metrics/auc/strided_slice_5/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_5" + op: "StridedSlice" + input: "linear/binary_logistic_head/metrics/auc/div_3" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_5/stack" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_5/stack_1" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_5/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 1 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/sub_1" + op: "Sub" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_4" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_6/stack" + 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: "linear/binary_logistic_head/metrics/auc/strided_slice_6/stack_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: 199 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_6/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_6" + op: "StridedSlice" + input: "linear/binary_logistic_head/metrics/auc/div_2" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_6/stack" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_6/stack_1" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_6/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_7/stack" + 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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_7/stack_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: "linear/binary_logistic_head/metrics/auc/strided_slice_7/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/strided_slice_7" + op: "StridedSlice" + input: "linear/binary_logistic_head/metrics/auc/div_2" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_7/stack" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_7/stack_1" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_7/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 1 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/add_11" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_6" + input: "linear/binary_logistic_head/metrics/auc/strided_slice_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/truediv_1/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: 2.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/truediv_1" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/auc/add_11" + input: "linear/binary_logistic_head/metrics/auc/truediv_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/Mul_1" + op: "Mul" + input: "linear/binary_logistic_head/metrics/auc/sub_1" + input: "linear/binary_logistic_head/metrics/auc/truediv_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc/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: "linear/binary_logistic_head/metrics/auc/update_op" + op: "Sum" + input: "linear/binary_logistic_head/metrics/auc/Mul_1" + input: "linear/binary_logistic_head/metrics/auc/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: "linear/binary_logistic_head/metrics/Cast_1" + op: "Cast" + input: "Const_1" + attr { + key: "DstT" + value { + type: DT_BOOL + } + } + attr { + key: "SrcT" + value { + type: DT_INT64 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/remove_squeezable_dimensions/Squeeze" + op: "Squeeze" + input: "linear/binary_logistic_head/predictions/logistic" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: -1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/Reshape/shape" + 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: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/Reshape" + op: "Reshape" + input: "linear/binary_logistic_head/metrics/auc_1/remove_squeezable_dimensions/Squeeze" + input: "linear/binary_logistic_head/metrics/auc_1/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/Reshape_1/shape" + 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: "\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/Reshape_1" + op: "Reshape" + input: "linear/binary_logistic_head/metrics/Cast_1" + input: "linear/binary_logistic_head/metrics/auc_1/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 200 + } + } + tensor_content: "\225\277\326\263\317\251\244;\317\251$<\267\376v<\317\251\244\370\311\005>G\357\n>\225\024\020>\3449\025>2_\032>\201\204\037>\317\251$>\036\317)>l\364.>\273\0314>\t?9>Wd>>\246\211C>\364\256H>C\324M>\221\371R>\340\036X>.D]>}ib>\313\216g>\032\264l>h\331q>\267\376v>\005$|>\252\244\200>Q7\203>\370\311\205>\240\\\210>G\357\212>\356\201\215>\225\024\220><\247\222>\3449\225>\213\314\227>2_\232>\331\361\234>\201\204\237>(\027\242>\317\251\244>v<\247>\036\317\251>\305a\254>l\364\256>\023\207\261>\273\031\264>b\254\266>\t?\271>\260\321\273>Wd\276>\377\366\300>\246\211\303>M\034\306>\364\256\310>\234A\313>C\324\315>\352f\320>\221\371\322>9\214\325>\340\036\330>\207\261\332>.D\335>\326\326\337>}i\342>$\374\344>\313\216\347>r!\352>\032\264\354>\301F\357>h\331\361>\017l\364>\267\376\366>^\221\371>\005$\374>\254\266\376>\252\244\000?\375\355\001?Q7\003?\245\200\004?\370\311\005?L\023\007?\240\\\010?\363\245\t?G\357\n?\2328\014?\356\201\r?B\313\016?\225\024\020?\351]\021?<\247\022?\220\360\023?\3449\025?7\203\026?\213\314\027?\337\025\031?2_\032?\206\250\033?\331\361\034?-;\036?\201\204\037?\324\315 ?(\027\"?{`#?\317\251$?#\363%?v<\'?\312\205(?\036\317)?q\030+?\305a,?\030\253-?l\364.?\300=0?\023\2071?g\3202?\273\0314?\016c5?b\2546?\265\3657?\t?9?]\210:?\260\321;?\004\033=?Wd>?\253\255??\377\366@?R@B?\246\211C?\372\322D?M\034F?\241eG?\364\256H?H\370I?\234AK?\357\212L?C\324M?\227\035O?\352fP?>\260Q?\221\371R?\345BT?9\214U?\214\325V?\340\036X?3hY?\207\261Z?\333\372[?.D]?\202\215^?\326\326_?) a?}ib?\320\262c?$\374d?xEf?\313\216g?\037\330h?r!j?\306jk?\032\264l?m\375m?\301Fo?\025\220p?h\331q?\274\"s?\017lt?c\265u?\267\376v?\nHx?^\221y?\262\332z?\005$|?Ym}?\254\266~?\001\000\200?" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/ExpandDims/dim" + 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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/ExpandDims" + op: "ExpandDims" + input: "linear/binary_logistic_head/metrics/auc_1/Const" + input: "linear/binary_logistic_head/metrics/auc_1/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: 200 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/stack" + 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: "\001\000\000\000x\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/Tile" + op: "Tile" + input: "linear/binary_logistic_head/metrics/auc_1/ExpandDims" + input: "linear/binary_logistic_head/metrics/auc_1/stack" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/transpose/Rank" + op: "Rank" + input: "linear/binary_logistic_head/metrics/auc_1/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/transpose/sub/y" + 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: "linear/binary_logistic_head/metrics/auc_1/transpose/sub" + op: "Sub" + input: "linear/binary_logistic_head/metrics/auc_1/transpose/Rank" + input: "linear/binary_logistic_head/metrics/auc_1/transpose/sub/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/transpose/Range/start" + 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: "linear/binary_logistic_head/metrics/auc_1/transpose/Range/delta" + 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: "linear/binary_logistic_head/metrics/auc_1/transpose/Range" + op: "Range" + input: "linear/binary_logistic_head/metrics/auc_1/transpose/Range/start" + input: "linear/binary_logistic_head/metrics/auc_1/transpose/Rank" + input: "linear/binary_logistic_head/metrics/auc_1/transpose/Range/delta" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/transpose/sub_1" + op: "Sub" + input: "linear/binary_logistic_head/metrics/auc_1/transpose/sub" + input: "linear/binary_logistic_head/metrics/auc_1/transpose/Range" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/transpose" + op: "Transpose" + input: "linear/binary_logistic_head/metrics/auc_1/Reshape" + input: "linear/binary_logistic_head/metrics/auc_1/transpose/sub_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/Tile_1/multiples" + 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: "\310\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/Tile_1" + op: "Tile" + input: "linear/binary_logistic_head/metrics/auc_1/transpose" + input: "linear/binary_logistic_head/metrics/auc_1/Tile_1/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/Greater" + op: "Greater" + input: "linear/binary_logistic_head/metrics/auc_1/Tile_1" + input: "linear/binary_logistic_head/metrics/auc_1/Tile" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/LogicalNot" + op: "LogicalNot" + input: "linear/binary_logistic_head/metrics/auc_1/Greater" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/Tile_2/multiples" + 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: "\310\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/Tile_2" + op: "Tile" + input: "linear/binary_logistic_head/metrics/auc_1/Reshape_1" + input: "linear/binary_logistic_head/metrics/auc_1/Tile_2/multiples" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/LogicalNot_1" + op: "LogicalNot" + input: "linear/binary_logistic_head/metrics/auc_1/Tile_2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/zeros" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 200 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/true_positives" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 200 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/true_positives/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/auc_1/true_positives" + input: "linear/binary_logistic_head/metrics/auc_1/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc_1/true_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/true_positives/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/auc_1/true_positives" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc_1/true_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/LogicalAnd" + op: "LogicalAnd" + input: "linear/binary_logistic_head/metrics/auc_1/Tile_2" + input: "linear/binary_logistic_head/metrics/auc_1/Greater" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/ToFloat_1" + op: "Cast" + input: "linear/binary_logistic_head/metrics/auc_1/LogicalAnd" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_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: "linear/binary_logistic_head/metrics/auc_1/Sum" + op: "Sum" + input: "linear/binary_logistic_head/metrics/auc_1/ToFloat_1" + input: "linear/binary_logistic_head/metrics/auc_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: 200 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/AssignAdd" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/auc_1/true_positives" + input: "linear/binary_logistic_head/metrics/auc_1/Sum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc_1/true_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/zeros_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 200 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/false_negatives" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 200 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/false_negatives/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/auc_1/false_negatives" + input: "linear/binary_logistic_head/metrics/auc_1/zeros_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc_1/false_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/false_negatives/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/auc_1/false_negatives" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc_1/false_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/LogicalAnd_1" + op: "LogicalAnd" + input: "linear/binary_logistic_head/metrics/auc_1/Tile_2" + input: "linear/binary_logistic_head/metrics/auc_1/LogicalNot" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/ToFloat_2" + op: "Cast" + input: "linear/binary_logistic_head/metrics/auc_1/LogicalAnd_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/Sum_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: "linear/binary_logistic_head/metrics/auc_1/Sum_1" + op: "Sum" + input: "linear/binary_logistic_head/metrics/auc_1/ToFloat_2" + input: "linear/binary_logistic_head/metrics/auc_1/Sum_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: 200 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/AssignAdd_1" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/auc_1/false_negatives" + input: "linear/binary_logistic_head/metrics/auc_1/Sum_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc_1/false_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/zeros_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 200 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/true_negatives" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 200 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/true_negatives/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/auc_1/true_negatives" + input: "linear/binary_logistic_head/metrics/auc_1/zeros_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc_1/true_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/true_negatives/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/auc_1/true_negatives" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc_1/true_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/LogicalAnd_2" + op: "LogicalAnd" + input: "linear/binary_logistic_head/metrics/auc_1/LogicalNot_1" + input: "linear/binary_logistic_head/metrics/auc_1/LogicalNot" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/ToFloat_3" + op: "Cast" + input: "linear/binary_logistic_head/metrics/auc_1/LogicalAnd_2" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/Sum_2/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: "linear/binary_logistic_head/metrics/auc_1/Sum_2" + op: "Sum" + input: "linear/binary_logistic_head/metrics/auc_1/ToFloat_3" + input: "linear/binary_logistic_head/metrics/auc_1/Sum_2/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: 200 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/AssignAdd_2" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/auc_1/true_negatives" + input: "linear/binary_logistic_head/metrics/auc_1/Sum_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc_1/true_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/zeros_3" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 200 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/false_positives" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 200 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/false_positives/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/auc_1/false_positives" + input: "linear/binary_logistic_head/metrics/auc_1/zeros_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc_1/false_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/false_positives/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/auc_1/false_positives" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc_1/false_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/LogicalAnd_3" + op: "LogicalAnd" + input: "linear/binary_logistic_head/metrics/auc_1/LogicalNot_1" + input: "linear/binary_logistic_head/metrics/auc_1/Greater" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/ToFloat_4" + op: "Cast" + input: "linear/binary_logistic_head/metrics/auc_1/LogicalAnd_3" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/Sum_3/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: "linear/binary_logistic_head/metrics/auc_1/Sum_3" + op: "Sum" + input: "linear/binary_logistic_head/metrics/auc_1/ToFloat_4" + input: "linear/binary_logistic_head/metrics/auc_1/Sum_3/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: 200 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/AssignAdd_3" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/auc_1/false_positives" + input: "linear/binary_logistic_head/metrics/auc_1/Sum_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc_1/false_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/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: 9.99999997475e-07 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc_1/true_positives/read" + input: "linear/binary_logistic_head/metrics/auc_1/add/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add_1" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc_1/true_positives/read" + input: "linear/binary_logistic_head/metrics/auc_1/false_negatives/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add_2/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.99999997475e-07 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add_2" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc_1/add_1" + input: "linear/binary_logistic_head/metrics/auc_1/add_2/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/div" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/auc_1/add" + input: "linear/binary_logistic_head/metrics/auc_1/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add_3/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.99999997475e-07 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add_3" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc_1/true_positives/read" + input: "linear/binary_logistic_head/metrics/auc_1/add_3/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add_4" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc_1/true_positives/read" + input: "linear/binary_logistic_head/metrics/auc_1/false_positives/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add_5/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.99999997475e-07 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add_5" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc_1/add_4" + input: "linear/binary_logistic_head/metrics/auc_1/add_5/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/div_1" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/auc_1/add_3" + input: "linear/binary_logistic_head/metrics/auc_1/add_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice/stack" + 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: "linear/binary_logistic_head/metrics/auc_1/strided_slice/stack_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: 199 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice" + op: "StridedSlice" + input: "linear/binary_logistic_head/metrics/auc_1/div" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice/stack" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice/stack_1" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_1/stack" + 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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_1/stack_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: "linear/binary_logistic_head/metrics/auc_1/strided_slice_1/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_1" + op: "StridedSlice" + input: "linear/binary_logistic_head/metrics/auc_1/div" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_1/stack" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_1/stack_1" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 1 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/sub" + op: "Sub" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_2/stack" + 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: "linear/binary_logistic_head/metrics/auc_1/strided_slice_2/stack_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: 199 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_2/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_2" + op: "StridedSlice" + input: "linear/binary_logistic_head/metrics/auc_1/div_1" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_2/stack" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_2/stack_1" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_2/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_3/stack" + 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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_3/stack_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: "linear/binary_logistic_head/metrics/auc_1/strided_slice_3/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_3" + op: "StridedSlice" + input: "linear/binary_logistic_head/metrics/auc_1/div_1" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_3/stack" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_3/stack_1" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_3/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 1 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add_6" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_2" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/truediv/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: 2.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/truediv" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/auc_1/add_6" + input: "linear/binary_logistic_head/metrics/auc_1/truediv/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/Mul" + op: "Mul" + input: "linear/binary_logistic_head/metrics/auc_1/sub" + input: "linear/binary_logistic_head/metrics/auc_1/truediv" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/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: "linear/binary_logistic_head/metrics/auc_1/value" + op: "Sum" + input: "linear/binary_logistic_head/metrics/auc_1/Mul" + input: "linear/binary_logistic_head/metrics/auc_1/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: "linear/binary_logistic_head/metrics/auc_1/add_7/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.99999997475e-07 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add_7" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc_1/AssignAdd" + input: "linear/binary_logistic_head/metrics/auc_1/add_7/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add_8" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc_1/AssignAdd" + input: "linear/binary_logistic_head/metrics/auc_1/AssignAdd_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add_9/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.99999997475e-07 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add_9" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc_1/add_8" + input: "linear/binary_logistic_head/metrics/auc_1/add_9/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/div_2" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/auc_1/add_7" + input: "linear/binary_logistic_head/metrics/auc_1/add_9" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add_10/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.99999997475e-07 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add_10" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc_1/AssignAdd" + input: "linear/binary_logistic_head/metrics/auc_1/add_10/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add_11" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc_1/AssignAdd" + input: "linear/binary_logistic_head/metrics/auc_1/AssignAdd_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add_12/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.99999997475e-07 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add_12" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc_1/add_11" + input: "linear/binary_logistic_head/metrics/auc_1/add_12/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/div_3" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/auc_1/add_10" + input: "linear/binary_logistic_head/metrics/auc_1/add_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 200 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_4/stack" + 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: "linear/binary_logistic_head/metrics/auc_1/strided_slice_4/stack_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: 199 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_4/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_4" + op: "StridedSlice" + input: "linear/binary_logistic_head/metrics/auc_1/div_2" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_4/stack" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_4/stack_1" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_4/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_5/stack" + 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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_5/stack_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: "linear/binary_logistic_head/metrics/auc_1/strided_slice_5/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_5" + op: "StridedSlice" + input: "linear/binary_logistic_head/metrics/auc_1/div_2" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_5/stack" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_5/stack_1" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_5/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 1 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/sub_1" + op: "Sub" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_4" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_6/stack" + 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: "linear/binary_logistic_head/metrics/auc_1/strided_slice_6/stack_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: 199 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_6/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_6" + op: "StridedSlice" + input: "linear/binary_logistic_head/metrics/auc_1/div_3" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_6/stack" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_6/stack_1" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_6/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_7/stack" + 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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_7/stack_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: "linear/binary_logistic_head/metrics/auc_1/strided_slice_7/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/strided_slice_7" + op: "StridedSlice" + input: "linear/binary_logistic_head/metrics/auc_1/div_3" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_7/stack" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_7/stack_1" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_7/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 1 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/add_13" + op: "Add" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_6" + input: "linear/binary_logistic_head/metrics/auc_1/strided_slice_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/truediv_1/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: 2.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/truediv_1" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/auc_1/add_13" + input: "linear/binary_logistic_head/metrics/auc_1/truediv_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/Mul_1" + op: "Mul" + input: "linear/binary_logistic_head/metrics/auc_1/sub_1" + input: "linear/binary_logistic_head/metrics/auc_1/truediv_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 199 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/auc_1/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: "linear/binary_logistic_head/metrics/auc_1/update_op" + op: "Sum" + input: "linear/binary_logistic_head/metrics/auc_1/Mul_1" + input: "linear/binary_logistic_head/metrics/auc_1/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: "linear/binary_logistic_head/metrics/GreaterEqual/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.5 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/GreaterEqual" + op: "GreaterEqual" + input: "linear/binary_logistic_head/predictions/logistic" + input: "linear/binary_logistic_head/metrics/GreaterEqual/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/ToFloat_6" + op: "Cast" + input: "linear/binary_logistic_head/metrics/GreaterEqual" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/remove_squeezable_dimensions_1/Squeeze" + op: "Squeeze" + input: "linear/binary_logistic_head/metrics/ToFloat_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: -1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/Cast_2" + op: "Cast" + input: "linear/binary_logistic_head/metrics/remove_squeezable_dimensions_1/Squeeze" + attr { + key: "DstT" + value { + type: DT_INT64 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/Equal_1" + op: "Equal" + input: "linear/binary_logistic_head/metrics/Cast_2" + input: "Const_1" + attr { + key: "T" + value { + type: DT_INT64 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/ToFloat_7" + op: "Cast" + input: "linear/binary_logistic_head/metrics/Equal_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy_1/zeros" + 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: "linear/binary_logistic_head/metrics/accuracy_1/total" + op: "VariableV2" + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy_1/total/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/accuracy_1/total" + input: "linear/binary_logistic_head/metrics/accuracy_1/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/accuracy_1/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy_1/total/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/accuracy_1/total" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/accuracy_1/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy_1/zeros_1" + 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: "linear/binary_logistic_head/metrics/accuracy_1/count" + op: "VariableV2" + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy_1/count/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/accuracy_1/count" + input: "linear/binary_logistic_head/metrics/accuracy_1/zeros_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/accuracy_1/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy_1/count/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/accuracy_1/count" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/accuracy_1/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy_1/Size" + 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: 120 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy_1/ToFloat_1" + op: "Cast" + input: "linear/binary_logistic_head/metrics/accuracy_1/Size" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy_1/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: "linear/binary_logistic_head/metrics/accuracy_1/Sum" + op: "Sum" + input: "linear/binary_logistic_head/metrics/ToFloat_7" + input: "linear/binary_logistic_head/metrics/accuracy_1/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: "linear/binary_logistic_head/metrics/accuracy_1/AssignAdd" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/accuracy_1/total" + input: "linear/binary_logistic_head/metrics/accuracy_1/Sum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/accuracy_1/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy_1/AssignAdd_1" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/accuracy_1/count" + input: "linear/binary_logistic_head/metrics/accuracy_1/ToFloat_1" + input: "^linear/binary_logistic_head/metrics/ToFloat_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/accuracy_1/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy_1/Greater/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.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy_1/Greater" + op: "Greater" + input: "linear/binary_logistic_head/metrics/accuracy_1/count/read" + input: "linear/binary_logistic_head/metrics/accuracy_1/Greater/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy_1/truediv" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/accuracy_1/total/read" + input: "linear/binary_logistic_head/metrics/accuracy_1/count/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy_1/value/e" + 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: "linear/binary_logistic_head/metrics/accuracy_1/value" + op: "Select" + input: "linear/binary_logistic_head/metrics/accuracy_1/Greater" + input: "linear/binary_logistic_head/metrics/accuracy_1/truediv" + input: "linear/binary_logistic_head/metrics/accuracy_1/value/e" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy_1/Greater_1/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.0 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy_1/Greater_1" + op: "Greater" + input: "linear/binary_logistic_head/metrics/accuracy_1/AssignAdd_1" + input: "linear/binary_logistic_head/metrics/accuracy_1/Greater_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy_1/truediv_1" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/accuracy_1/AssignAdd" + input: "linear/binary_logistic_head/metrics/accuracy_1/AssignAdd_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/accuracy_1/update_op/e" + 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: "linear/binary_logistic_head/metrics/accuracy_1/update_op" + op: "Select" + input: "linear/binary_logistic_head/metrics/accuracy_1/Greater_1" + input: "linear/binary_logistic_head/metrics/accuracy_1/truediv_1" + input: "linear/binary_logistic_head/metrics/accuracy_1/update_op/e" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/Cast" + op: "Cast" + input: "Const_1" + attr { + key: "DstT" + value { + type: DT_BOOL + } + } + attr { + key: "SrcT" + value { + type: DT_INT64 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/remove_squeezable_dimensions/Squeeze" + op: "Squeeze" + input: "linear/binary_logistic_head/predictions/logistic" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: -1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/Reshape/shape" + 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: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/Reshape" + op: "Reshape" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/remove_squeezable_dimensions/Squeeze" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/Reshape_1/shape" + 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: "\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/Reshape_1" + op: "Reshape" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/Cast" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/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: 0.5 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/ExpandDims/dim" + 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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/ExpandDims" + op: "ExpandDims" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/Const" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/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: "linear/binary_logistic_head/metrics/precision_at_thresholds/stack" + 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: "\001\000\000\000x\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/Tile" + op: "Tile" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/ExpandDims" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/stack" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/transpose/Rank" + op: "Rank" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/transpose/sub/y" + 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: "linear/binary_logistic_head/metrics/precision_at_thresholds/transpose/sub" + op: "Sub" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/transpose/Rank" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/transpose/sub/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/transpose/Range/start" + 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: "linear/binary_logistic_head/metrics/precision_at_thresholds/transpose/Range/delta" + 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: "linear/binary_logistic_head/metrics/precision_at_thresholds/transpose/Range" + op: "Range" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/transpose/Range/start" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/transpose/Rank" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/transpose/Range/delta" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/transpose/sub_1" + op: "Sub" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/transpose/sub" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/transpose/Range" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/transpose" + op: "Transpose" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/Reshape" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/transpose/sub_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/Tile_1/multiples" + 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: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/Tile_1" + op: "Tile" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/transpose" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/Tile_1/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/Greater" + op: "Greater" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/Tile_1" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/Tile" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/Tile_2/multiples" + 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: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/Tile_2" + op: "Tile" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/Reshape_1" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/Tile_2/multiples" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/LogicalNot" + op: "LogicalNot" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/Tile_2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/zeros" + 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: "linear/binary_logistic_head/metrics/precision_at_thresholds/true_positives" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/true_positives/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/true_positives" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/precision_at_thresholds/true_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/true_positives/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/true_positives" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/precision_at_thresholds/true_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/LogicalAnd" + op: "LogicalAnd" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/Tile_2" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/Greater" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/ToFloat_1" + op: "Cast" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/LogicalAnd" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/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: "linear/binary_logistic_head/metrics/precision_at_thresholds/Sum" + op: "Sum" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/ToFloat_1" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/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: "linear/binary_logistic_head/metrics/precision_at_thresholds/AssignAdd" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/true_positives" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/Sum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/precision_at_thresholds/true_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/zeros_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: "linear/binary_logistic_head/metrics/precision_at_thresholds/false_positives" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/false_positives/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/false_positives" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/zeros_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/precision_at_thresholds/false_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/false_positives/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/false_positives" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/precision_at_thresholds/false_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/LogicalAnd_1" + op: "LogicalAnd" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/LogicalNot" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/Greater" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/ToFloat_2" + op: "Cast" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/LogicalAnd_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/Sum_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: "linear/binary_logistic_head/metrics/precision_at_thresholds/Sum_1" + op: "Sum" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/ToFloat_2" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/Sum_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: "linear/binary_logistic_head/metrics/precision_at_thresholds/AssignAdd_1" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/false_positives" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/Sum_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/precision_at_thresholds/false_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/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: 1.00000001169e-07 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/add" + op: "Add" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/add/x" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/true_positives/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/add_1" + op: "Add" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/add" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/false_positives/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/precision_value" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/true_positives/read" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/add_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/add_2/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.00000001169e-07 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/add_2" + op: "Add" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/add_2/x" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/AssignAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/add_3" + op: "Add" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/add_2" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/AssignAdd_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/precision_at_thresholds/precision_update_op" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/AssignAdd" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/Squeeze" + op: "Squeeze" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/precision_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/Squeeze_1" + op: "Squeeze" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/precision_update_op" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/Cast" + op: "Cast" + input: "Const_1" + attr { + key: "DstT" + value { + type: DT_BOOL + } + } + attr { + key: "SrcT" + value { + type: DT_INT64 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/remove_squeezable_dimensions/Squeeze" + op: "Squeeze" + input: "linear/binary_logistic_head/predictions/logistic" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: -1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/Reshape/shape" + 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: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/Reshape" + op: "Reshape" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/remove_squeezable_dimensions/Squeeze" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 120 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/Reshape_1/shape" + 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: "\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/Reshape_1" + op: "Reshape" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/Cast" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/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: 0.5 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/ExpandDims/dim" + 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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/ExpandDims" + op: "ExpandDims" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/Const" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/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: "linear/binary_logistic_head/metrics/recall_at_thresholds/stack" + 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: "\001\000\000\000x\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/Tile" + op: "Tile" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/ExpandDims" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/stack" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/transpose/Rank" + op: "Rank" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/transpose/sub/y" + 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: "linear/binary_logistic_head/metrics/recall_at_thresholds/transpose/sub" + op: "Sub" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/transpose/Rank" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/transpose/sub/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/transpose/Range/start" + 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: "linear/binary_logistic_head/metrics/recall_at_thresholds/transpose/Range/delta" + 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: "linear/binary_logistic_head/metrics/recall_at_thresholds/transpose/Range" + op: "Range" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/transpose/Range/start" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/transpose/Rank" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/transpose/Range/delta" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/transpose/sub_1" + op: "Sub" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/transpose/sub" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/transpose/Range" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/transpose" + op: "Transpose" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/Reshape" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/transpose/sub_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/Tile_1/multiples" + 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: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/Tile_1" + op: "Tile" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/transpose" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/Tile_1/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/Greater" + op: "Greater" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/Tile_1" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/Tile" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/LogicalNot" + op: "LogicalNot" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/Greater" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/Tile_2/multiples" + 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: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/Tile_2" + op: "Tile" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/Reshape_1" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/Tile_2/multiples" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/zeros" + 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: "linear/binary_logistic_head/metrics/recall_at_thresholds/true_positives" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/true_positives/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/true_positives" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/recall_at_thresholds/true_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/true_positives/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/true_positives" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/recall_at_thresholds/true_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/LogicalAnd" + op: "LogicalAnd" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/Tile_2" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/Greater" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/ToFloat_1" + op: "Cast" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/LogicalAnd" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/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: "linear/binary_logistic_head/metrics/recall_at_thresholds/Sum" + op: "Sum" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/ToFloat_1" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/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: "linear/binary_logistic_head/metrics/recall_at_thresholds/AssignAdd" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/true_positives" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/Sum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/recall_at_thresholds/true_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/zeros_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: "linear/binary_logistic_head/metrics/recall_at_thresholds/false_negatives" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + 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: "" + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/false_negatives/Assign" + op: "Assign" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/false_negatives" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/zeros_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/recall_at_thresholds/false_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/false_negatives/read" + op: "Identity" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/false_negatives" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/recall_at_thresholds/false_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/LogicalAnd_1" + op: "LogicalAnd" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/Tile_2" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/LogicalNot" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/ToFloat_2" + op: "Cast" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/LogicalAnd_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 120 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/Sum_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: "linear/binary_logistic_head/metrics/recall_at_thresholds/Sum_1" + op: "Sum" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/ToFloat_2" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/Sum_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: "linear/binary_logistic_head/metrics/recall_at_thresholds/AssignAdd_1" + op: "AssignAdd" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/false_negatives" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/Sum_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/recall_at_thresholds/false_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/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: 1.00000001169e-07 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/add" + op: "Add" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/add/x" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/true_positives/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/add_1" + op: "Add" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/add" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/false_negatives/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/recall_value" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/true_positives/read" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/add_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/add_2/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.00000001169e-07 + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/add_2" + op: "Add" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/add_2/x" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/AssignAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/add_3" + op: "Add" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/add_2" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/AssignAdd_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/recall_at_thresholds/recall_update_op" + op: "RealDiv" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/AssignAdd" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/Squeeze_2" + op: "Squeeze" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/recall_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + } + } + } +} +node { + name: "linear/binary_logistic_head/metrics/Squeeze_3" + op: "Squeeze" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/recall_update_op" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + } + } + } +} +node { + name: "linear/binary_logistic_head/_classification_output_alternatives/Shape" + 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: "x\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/_classification_output_alternatives/strided_slice/stack" + 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: "linear/binary_logistic_head/_classification_output_alternatives/strided_slice/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/_classification_output_alternatives/strided_slice/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/_classification_output_alternatives/strided_slice" + op: "StridedSlice" + input: "linear/binary_logistic_head/_classification_output_alternatives/Shape" + input: "linear/binary_logistic_head/_classification_output_alternatives/strided_slice/stack" + input: "linear/binary_logistic_head/_classification_output_alternatives/strided_slice/stack_1" + input: "linear/binary_logistic_head/_classification_output_alternatives/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "linear/binary_logistic_head/_classification_output_alternatives/Shape_1" + 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: "x\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "linear/binary_logistic_head/_classification_output_alternatives/strided_slice_1/stack" + 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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/_classification_output_alternatives/strided_slice_1/stack_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: 2 + } + } + } +} +node { + name: "linear/binary_logistic_head/_classification_output_alternatives/strided_slice_1/stack_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: 1 + } + } + } +} +node { + name: "linear/binary_logistic_head/_classification_output_alternatives/strided_slice_1" + op: "StridedSlice" + input: "linear/binary_logistic_head/_classification_output_alternatives/Shape_1" + input: "linear/binary_logistic_head/_classification_output_alternatives/strided_slice_1/stack" + input: "linear/binary_logistic_head/_classification_output_alternatives/strided_slice_1/stack_1" + input: "linear/binary_logistic_head/_classification_output_alternatives/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "linear/binary_logistic_head/_classification_output_alternatives/range/start" + 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: "linear/binary_logistic_head/_classification_output_alternatives/range/delta" + 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: "linear/binary_logistic_head/_classification_output_alternatives/range" + op: "Range" + input: "linear/binary_logistic_head/_classification_output_alternatives/range/start" + input: "linear/binary_logistic_head/_classification_output_alternatives/strided_slice_1" + input: "linear/binary_logistic_head/_classification_output_alternatives/range/delta" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/_classification_output_alternatives/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: 0 + } + } + } +} +node { + name: "linear/binary_logistic_head/_classification_output_alternatives/ExpandDims" + op: "ExpandDims" + input: "linear/binary_logistic_head/_classification_output_alternatives/range" + input: "linear/binary_logistic_head/_classification_output_alternatives/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: "linear/binary_logistic_head/_classification_output_alternatives/Tile/multiples/1" + 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: "linear/binary_logistic_head/_classification_output_alternatives/Tile/multiples" + op: "Pack" + input: "linear/binary_logistic_head/_classification_output_alternatives/strided_slice" + input: "linear/binary_logistic_head/_classification_output_alternatives/Tile/multiples/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "linear/binary_logistic_head/_classification_output_alternatives/Tile" + op: "Tile" + input: "linear/binary_logistic_head/_classification_output_alternatives/ExpandDims" + input: "linear/binary_logistic_head/_classification_output_alternatives/Tile/multiples" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "linear/binary_logistic_head/_classification_output_alternatives/classes_tensor" + op: "AsString" + input: "linear/binary_logistic_head/_classification_output_alternatives/Tile" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "fill" + value { + s: "" + } + } + attr { + key: "precision" + value { + i: -1 + } + } + attr { + key: "scientific" + value { + b: false + } + } + attr { + key: "shortest" + value { + b: false + } + } + attr { + key: "width" + value { + i: -1 + } + } +} +node { + name: "init" + op: "NoOp" + input: "^global_step/Assign" + input: "^linear//weight/part_0/Assign" + input: "^linear/bias_weight/part_0/Assign" + input: "^linear/binary_logistic_head/linear//weight/part_0/Ftrl/Assign" + input: "^linear/binary_logistic_head/linear//weight/part_0/Ftrl_1/Assign" + input: "^linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl/Assign" + input: "^linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl_1/Assign" +} +node { + name: "init_1" + op: "NoOp" +} +node { + name: "group_deps" + op: "NoOp" + input: "^init" + input: "^init_1" +} +node { + name: "report_uninitialized_variables/IsVariableInitialized" + op: "IsVariableInitialized" + input: "global_step" + attr { + key: "_class" + value { + list { + s: "loc:@global_step" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT64 + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_1" + op: "IsVariableInitialized" + input: "linear//weight/part_0" + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_2" + op: "IsVariableInitialized" + input: "linear/bias_weight/part_0" + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_3" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/linear//weight/part_0/Ftrl" + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_4" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/linear//weight/part_0/Ftrl_1" + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_5" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl" + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_6" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl_1" + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_7" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/mean/total" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_8" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/mean/count" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_9" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/accuracy/total" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/accuracy/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_10" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/accuracy/count" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/accuracy/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_11" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/mean_1/total" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_1/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_12" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/mean_1/count" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_1/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_13" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/mean_2/total" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_2/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_14" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/mean_2/count" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_2/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_15" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/mean_3/total" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_3/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_16" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/mean_3/count" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/mean_3/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_17" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/auc/true_positives" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc/true_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_18" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/auc/false_negatives" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc/false_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_19" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/auc/true_negatives" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc/true_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_20" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/auc/false_positives" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc/false_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_21" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/auc_1/true_positives" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc_1/true_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_22" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/auc_1/false_negatives" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc_1/false_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_23" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/auc_1/true_negatives" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc_1/true_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_24" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/auc_1/false_positives" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/auc_1/false_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_25" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/accuracy_1/total" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/accuracy_1/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_26" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/accuracy_1/count" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/accuracy_1/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_27" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/true_positives" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/precision_at_thresholds/true_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_28" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/precision_at_thresholds/false_positives" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/precision_at_thresholds/false_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_29" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/true_positives" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/recall_at_thresholds/true_positives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_30" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/metrics/recall_at_thresholds/false_negatives" + attr { + key: "_class" + value { + list { + s: "loc:@linear/binary_logistic_head/metrics/recall_at_thresholds/false_negatives" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/stack" + op: "Pack" + input: "report_uninitialized_variables/IsVariableInitialized" + input: "report_uninitialized_variables/IsVariableInitialized_1" + input: "report_uninitialized_variables/IsVariableInitialized_2" + input: "report_uninitialized_variables/IsVariableInitialized_3" + input: "report_uninitialized_variables/IsVariableInitialized_4" + input: "report_uninitialized_variables/IsVariableInitialized_5" + input: "report_uninitialized_variables/IsVariableInitialized_6" + input: "report_uninitialized_variables/IsVariableInitialized_7" + input: "report_uninitialized_variables/IsVariableInitialized_8" + input: "report_uninitialized_variables/IsVariableInitialized_9" + input: "report_uninitialized_variables/IsVariableInitialized_10" + input: "report_uninitialized_variables/IsVariableInitialized_11" + input: "report_uninitialized_variables/IsVariableInitialized_12" + input: "report_uninitialized_variables/IsVariableInitialized_13" + input: "report_uninitialized_variables/IsVariableInitialized_14" + input: "report_uninitialized_variables/IsVariableInitialized_15" + input: "report_uninitialized_variables/IsVariableInitialized_16" + input: "report_uninitialized_variables/IsVariableInitialized_17" + input: "report_uninitialized_variables/IsVariableInitialized_18" + input: "report_uninitialized_variables/IsVariableInitialized_19" + input: "report_uninitialized_variables/IsVariableInitialized_20" + input: "report_uninitialized_variables/IsVariableInitialized_21" + input: "report_uninitialized_variables/IsVariableInitialized_22" + input: "report_uninitialized_variables/IsVariableInitialized_23" + input: "report_uninitialized_variables/IsVariableInitialized_24" + input: "report_uninitialized_variables/IsVariableInitialized_25" + input: "report_uninitialized_variables/IsVariableInitialized_26" + input: "report_uninitialized_variables/IsVariableInitialized_27" + input: "report_uninitialized_variables/IsVariableInitialized_28" + input: "report_uninitialized_variables/IsVariableInitialized_29" + input: "report_uninitialized_variables/IsVariableInitialized_30" + attr { + key: "N" + value { + i: 31 + } + } + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 31 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "report_uninitialized_variables/LogicalNot" + op: "LogicalNot" + input: "report_uninitialized_variables/stack" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 31 + } + } + } + } + } +} +node { + name: "report_uninitialized_variables/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 31 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 31 + } + } + string_val: "global_step" + string_val: "linear//weight/part_0" + string_val: "linear/bias_weight/part_0" + string_val: "linear/binary_logistic_head/linear//weight/part_0/Ftrl" + string_val: "linear/binary_logistic_head/linear//weight/part_0/Ftrl_1" + string_val: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl" + string_val: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl_1" + string_val: "linear/binary_logistic_head/metrics/mean/total" + string_val: "linear/binary_logistic_head/metrics/mean/count" + string_val: "linear/binary_logistic_head/metrics/accuracy/total" + string_val: "linear/binary_logistic_head/metrics/accuracy/count" + string_val: "linear/binary_logistic_head/metrics/mean_1/total" + string_val: "linear/binary_logistic_head/metrics/mean_1/count" + string_val: "linear/binary_logistic_head/metrics/mean_2/total" + string_val: "linear/binary_logistic_head/metrics/mean_2/count" + string_val: "linear/binary_logistic_head/metrics/mean_3/total" + string_val: "linear/binary_logistic_head/metrics/mean_3/count" + string_val: "linear/binary_logistic_head/metrics/auc/true_positives" + string_val: "linear/binary_logistic_head/metrics/auc/false_negatives" + string_val: "linear/binary_logistic_head/metrics/auc/true_negatives" + string_val: "linear/binary_logistic_head/metrics/auc/false_positives" + string_val: "linear/binary_logistic_head/metrics/auc_1/true_positives" + string_val: "linear/binary_logistic_head/metrics/auc_1/false_negatives" + string_val: "linear/binary_logistic_head/metrics/auc_1/true_negatives" + string_val: "linear/binary_logistic_head/metrics/auc_1/false_positives" + string_val: "linear/binary_logistic_head/metrics/accuracy_1/total" + string_val: "linear/binary_logistic_head/metrics/accuracy_1/count" + string_val: "linear/binary_logistic_head/metrics/precision_at_thresholds/true_positives" + string_val: "linear/binary_logistic_head/metrics/precision_at_thresholds/false_positives" + string_val: "linear/binary_logistic_head/metrics/recall_at_thresholds/true_positives" + string_val: "linear/binary_logistic_head/metrics/recall_at_thresholds/false_negatives" + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/Shape" + 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: 31 + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/strided_slice/stack" + 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: "report_uninitialized_variables/boolean_mask/strided_slice/stack_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: 1 + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/strided_slice/stack_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: 1 + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/strided_slice" + op: "StridedSlice" + input: "report_uninitialized_variables/boolean_mask/Shape" + input: "report_uninitialized_variables/boolean_mask/strided_slice/stack" + input: "report_uninitialized_variables/boolean_mask/strided_slice/stack_1" + input: "report_uninitialized_variables/boolean_mask/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/Prod/reduction_indices" + 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: "report_uninitialized_variables/boolean_mask/Prod" + op: "Prod" + input: "report_uninitialized_variables/boolean_mask/strided_slice" + input: "report_uninitialized_variables/boolean_mask/Prod/reduction_indices" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/Shape_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: 31 + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/strided_slice_1/stack" + 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: 1 + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/strided_slice_1/stack_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: "report_uninitialized_variables/boolean_mask/strided_slice_1/stack_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: 1 + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/strided_slice_1" + op: "StridedSlice" + input: "report_uninitialized_variables/boolean_mask/Shape_1" + input: "report_uninitialized_variables/boolean_mask/strided_slice_1/stack" + input: "report_uninitialized_variables/boolean_mask/strided_slice_1/stack_1" + input: "report_uninitialized_variables/boolean_mask/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 1 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/concat/values_0" + op: "Pack" + input: "report_uninitialized_variables/boolean_mask/Prod" + attr { + key: "N" + value { + i: 1 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/concat/axis" + 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: "report_uninitialized_variables/boolean_mask/concat" + op: "ConcatV2" + input: "report_uninitialized_variables/boolean_mask/concat/values_0" + input: "report_uninitialized_variables/boolean_mask/strided_slice_1" + input: "report_uninitialized_variables/boolean_mask/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 + } + } + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/Reshape" + op: "Reshape" + input: "report_uninitialized_variables/Const" + input: "report_uninitialized_variables/boolean_mask/concat" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 31 + } + } + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/Reshape_1/shape" + 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: -1 + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/Reshape_1" + op: "Reshape" + input: "report_uninitialized_variables/LogicalNot" + input: "report_uninitialized_variables/boolean_mask/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 31 + } + } + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/Where" + op: "Where" + input: "report_uninitialized_variables/boolean_mask/Reshape_1" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/Squeeze" + op: "Squeeze" + input: "report_uninitialized_variables/boolean_mask/Where" + attr { + key: "T" + value { + type: DT_INT64 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 1 + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/Gather" + op: "Gather" + input: "report_uninitialized_variables/boolean_mask/Reshape" + input: "report_uninitialized_variables/boolean_mask/Squeeze" + attr { + key: "Tindices" + value { + type: DT_INT64 + } + } + attr { + key: "Tparams" + value { + type: DT_STRING + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "validate_indices" + value { + b: true + } + } +} +node { + name: "report_uninitialized_resources/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "concat/axis" + 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: "concat" + op: "ConcatV2" + input: "report_uninitialized_variables/boolean_mask/Gather" + input: "report_uninitialized_resources/Const" + input: "concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "report_uninitialized_variables_1/IsVariableInitialized" + op: "IsVariableInitialized" + input: "global_step" + attr { + key: "_class" + value { + list { + s: "loc:@global_step" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT64 + } + } +} +node { + name: "report_uninitialized_variables_1/IsVariableInitialized_1" + op: "IsVariableInitialized" + input: "linear//weight/part_0" + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables_1/IsVariableInitialized_2" + op: "IsVariableInitialized" + input: "linear/bias_weight/part_0" + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables_1/IsVariableInitialized_3" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/linear//weight/part_0/Ftrl" + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables_1/IsVariableInitialized_4" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/linear//weight/part_0/Ftrl_1" + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables_1/IsVariableInitialized_5" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl" + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables_1/IsVariableInitialized_6" + op: "IsVariableInitialized" + input: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl_1" + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables_1/stack" + op: "Pack" + input: "report_uninitialized_variables_1/IsVariableInitialized" + input: "report_uninitialized_variables_1/IsVariableInitialized_1" + input: "report_uninitialized_variables_1/IsVariableInitialized_2" + input: "report_uninitialized_variables_1/IsVariableInitialized_3" + input: "report_uninitialized_variables_1/IsVariableInitialized_4" + input: "report_uninitialized_variables_1/IsVariableInitialized_5" + input: "report_uninitialized_variables_1/IsVariableInitialized_6" + attr { + key: "N" + value { + i: 7 + } + } + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "report_uninitialized_variables_1/LogicalNot" + op: "LogicalNot" + input: "report_uninitialized_variables_1/stack" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + } + } + } + } +} +node { + name: "report_uninitialized_variables_1/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 7 + } + } + string_val: "global_step" + string_val: "linear//weight/part_0" + string_val: "linear/bias_weight/part_0" + string_val: "linear/binary_logistic_head/linear//weight/part_0/Ftrl" + string_val: "linear/binary_logistic_head/linear//weight/part_0/Ftrl_1" + string_val: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl" + string_val: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl_1" + } + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/Shape" + 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: 7 + } + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/strided_slice/stack" + 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: "report_uninitialized_variables_1/boolean_mask/strided_slice/stack_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: 1 + } + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/strided_slice/stack_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: 1 + } + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/strided_slice" + op: "StridedSlice" + input: "report_uninitialized_variables_1/boolean_mask/Shape" + input: "report_uninitialized_variables_1/boolean_mask/strided_slice/stack" + input: "report_uninitialized_variables_1/boolean_mask/strided_slice/stack_1" + input: "report_uninitialized_variables_1/boolean_mask/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/Prod/reduction_indices" + 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: "report_uninitialized_variables_1/boolean_mask/Prod" + op: "Prod" + input: "report_uninitialized_variables_1/boolean_mask/strided_slice" + input: "report_uninitialized_variables_1/boolean_mask/Prod/reduction_indices" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/Shape_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: 7 + } + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/strided_slice_1/stack" + 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: 1 + } + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/strided_slice_1/stack_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: "report_uninitialized_variables_1/boolean_mask/strided_slice_1/stack_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: 1 + } + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/strided_slice_1" + op: "StridedSlice" + input: "report_uninitialized_variables_1/boolean_mask/Shape_1" + input: "report_uninitialized_variables_1/boolean_mask/strided_slice_1/stack" + input: "report_uninitialized_variables_1/boolean_mask/strided_slice_1/stack_1" + input: "report_uninitialized_variables_1/boolean_mask/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 1 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/concat/values_0" + op: "Pack" + input: "report_uninitialized_variables_1/boolean_mask/Prod" + attr { + key: "N" + value { + i: 1 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/concat/axis" + 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: "report_uninitialized_variables_1/boolean_mask/concat" + op: "ConcatV2" + input: "report_uninitialized_variables_1/boolean_mask/concat/values_0" + input: "report_uninitialized_variables_1/boolean_mask/strided_slice_1" + input: "report_uninitialized_variables_1/boolean_mask/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 + } + } + } + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/Reshape" + op: "Reshape" + input: "report_uninitialized_variables_1/Const" + input: "report_uninitialized_variables_1/boolean_mask/concat" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + } + } + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/Reshape_1/shape" + 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: -1 + } + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/Reshape_1" + op: "Reshape" + input: "report_uninitialized_variables_1/LogicalNot" + input: "report_uninitialized_variables_1/boolean_mask/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + } + } + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/Where" + op: "Where" + input: "report_uninitialized_variables_1/boolean_mask/Reshape_1" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/Squeeze" + op: "Squeeze" + input: "report_uninitialized_variables_1/boolean_mask/Where" + attr { + key: "T" + value { + type: DT_INT64 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 1 + } + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/Gather" + op: "Gather" + input: "report_uninitialized_variables_1/boolean_mask/Reshape" + input: "report_uninitialized_variables_1/boolean_mask/Squeeze" + attr { + key: "Tindices" + value { + type: DT_INT64 + } + } + attr { + key: "Tparams" + value { + type: DT_STRING + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "validate_indices" + value { + b: true + } + } +} +node { + name: "init_2" + op: "NoOp" + input: "^linear/binary_logistic_head/metrics/mean/total/Assign" + input: "^linear/binary_logistic_head/metrics/mean/count/Assign" + input: "^linear/binary_logistic_head/metrics/accuracy/total/Assign" + input: "^linear/binary_logistic_head/metrics/accuracy/count/Assign" + input: "^linear/binary_logistic_head/metrics/mean_1/total/Assign" + input: "^linear/binary_logistic_head/metrics/mean_1/count/Assign" + input: "^linear/binary_logistic_head/metrics/mean_2/total/Assign" + input: "^linear/binary_logistic_head/metrics/mean_2/count/Assign" + input: "^linear/binary_logistic_head/metrics/mean_3/total/Assign" + input: "^linear/binary_logistic_head/metrics/mean_3/count/Assign" + input: "^linear/binary_logistic_head/metrics/auc/true_positives/Assign" + input: "^linear/binary_logistic_head/metrics/auc/false_negatives/Assign" + input: "^linear/binary_logistic_head/metrics/auc/true_negatives/Assign" + input: "^linear/binary_logistic_head/metrics/auc/false_positives/Assign" + input: "^linear/binary_logistic_head/metrics/auc_1/true_positives/Assign" + input: "^linear/binary_logistic_head/metrics/auc_1/false_negatives/Assign" + input: "^linear/binary_logistic_head/metrics/auc_1/true_negatives/Assign" + input: "^linear/binary_logistic_head/metrics/auc_1/false_positives/Assign" + input: "^linear/binary_logistic_head/metrics/accuracy_1/total/Assign" + input: "^linear/binary_logistic_head/metrics/accuracy_1/count/Assign" + input: "^linear/binary_logistic_head/metrics/precision_at_thresholds/true_positives/Assign" + input: "^linear/binary_logistic_head/metrics/precision_at_thresholds/false_positives/Assign" + input: "^linear/binary_logistic_head/metrics/recall_at_thresholds/true_positives/Assign" + input: "^linear/binary_logistic_head/metrics/recall_at_thresholds/false_negatives/Assign" +} +node { + name: "init_all_tables" + op: "NoOp" +} +node { + name: "group_deps_1" + op: "NoOp" + input: "^init_2" + input: "^init_all_tables" +} +node { + name: "Merge/MergeSummary" + op: "MergeSummary" + input: "linear/binary_logistic_head/ScalarSummary" + attr { + key: "N" + value { + i: 1 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "save/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: "model" + } + } + } +} +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_7fd9cfd5816249a4a2dcfc23e3f328d0/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" + 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" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "save/SaveV2/tensor_names" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 7 + } + } + string_val: "global_step" + string_val: "linear//weight" + string_val: "linear//weight/_head/linear//weight/part_0/Ftrl" + string_val: "linear//weight/_head/linear//weight/part_0/Ftrl_1" + string_val: "linear/bias_weight" + string_val: "linear/bias_weight/d/linear/bias_weight/part_0/Ftrl" + string_val: "linear/bias_weight/d/linear/bias_weight/part_0/Ftrl_1" + } + } + } +} +node { + name: "save/SaveV2/shape_and_slices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 7 + } + } + string_val: "" + string_val: "1 1 0,1:0,1" + string_val: "1 1 0,1:0,1" + string_val: "1 1 0,1:0,1" + string_val: "1 0,1" + string_val: "1 0,1" + string_val: "1 0,1" + } + } + } +} +node { + name: "save/SaveV2" + op: "SaveV2" + input: "save/ShardedFilename" + input: "save/SaveV2/tensor_names" + input: "save/SaveV2/shape_and_slices" + input: "global_step" + input: "linear//weight/part_0/read" + input: "linear/binary_logistic_head/linear//weight/part_0/Ftrl/read" + input: "linear/binary_logistic_head/linear//weight/part_0/Ftrl_1/read" + input: "linear/bias_weight/part_0/read" + input: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl/read" + input: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl_1/read" + attr { + key: "dtypes" + value { + list { + type: DT_INT64 + 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" + 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" + 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" + attr { + key: "delete_old_dirs" + value { + b: true + } + } +} +node { + name: "save/Identity" + op: "Identity" + input: "save/Const" + input: "^save/control_dependency" + input: "^save/MergeV2Checkpoints" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "save/RestoreV2/tensor_names" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 1 + } + } + string_val: "global_step" + } + } + } +} +node { + name: "save/RestoreV2/shape_and_slices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 1 + } + } + string_val: "" + } + } + } +} +node { + name: "save/RestoreV2" + op: "RestoreV2" + input: "save/Const" + input: "save/RestoreV2/tensor_names" + input: "save/RestoreV2/shape_and_slices" + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "dtypes" + value { + list { + type: DT_INT64 + } + } + } +} +node { + name: "save/Assign" + op: "Assign" + input: "global_step" + input: "save/RestoreV2" + attr { + key: "T" + value { + type: DT_INT64 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@global_step" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/RestoreV2_1/tensor_names" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 1 + } + } + string_val: "linear//weight" + } + } + } +} +node { + name: "save/RestoreV2_1/shape_and_slices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 1 + } + } + string_val: "1 1 0,1:0,1" + } + } + } +} +node { + name: "save/RestoreV2_1" + op: "RestoreV2" + input: "save/Const" + input: "save/RestoreV2_1/tensor_names" + input: "save/RestoreV2_1/shape_and_slices" + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "dtypes" + value { + list { + type: DT_FLOAT + } + } + } +} +node { + name: "save/Assign_1" + op: "Assign" + input: "linear//weight/part_0" + input: "save/RestoreV2_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/RestoreV2_2/tensor_names" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 1 + } + } + string_val: "linear//weight/_head/linear//weight/part_0/Ftrl" + } + } + } +} +node { + name: "save/RestoreV2_2/shape_and_slices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 1 + } + } + string_val: "1 1 0,1:0,1" + } + } + } +} +node { + name: "save/RestoreV2_2" + op: "RestoreV2" + input: "save/Const" + input: "save/RestoreV2_2/tensor_names" + input: "save/RestoreV2_2/shape_and_slices" + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "dtypes" + value { + list { + type: DT_FLOAT + } + } + } +} +node { + name: "save/Assign_2" + op: "Assign" + input: "linear/binary_logistic_head/linear//weight/part_0/Ftrl" + input: "save/RestoreV2_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/RestoreV2_3/tensor_names" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 1 + } + } + string_val: "linear//weight/_head/linear//weight/part_0/Ftrl_1" + } + } + } +} +node { + name: "save/RestoreV2_3/shape_and_slices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 1 + } + } + string_val: "1 1 0,1:0,1" + } + } + } +} +node { + name: "save/RestoreV2_3" + op: "RestoreV2" + input: "save/Const" + input: "save/RestoreV2_3/tensor_names" + input: "save/RestoreV2_3/shape_and_slices" + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "dtypes" + value { + list { + type: DT_FLOAT + } + } + } +} +node { + name: "save/Assign_3" + op: "Assign" + input: "linear/binary_logistic_head/linear//weight/part_0/Ftrl_1" + input: "save/RestoreV2_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear//weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/RestoreV2_4/tensor_names" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 1 + } + } + string_val: "linear/bias_weight" + } + } + } +} +node { + name: "save/RestoreV2_4/shape_and_slices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 1 + } + } + string_val: "1 0,1" + } + } + } +} +node { + name: "save/RestoreV2_4" + op: "RestoreV2" + input: "save/Const" + input: "save/RestoreV2_4/tensor_names" + input: "save/RestoreV2_4/shape_and_slices" + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "dtypes" + value { + list { + type: DT_FLOAT + } + } + } +} +node { + name: "save/Assign_4" + op: "Assign" + input: "linear/bias_weight/part_0" + input: "save/RestoreV2_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/RestoreV2_5/tensor_names" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 1 + } + } + string_val: "linear/bias_weight/d/linear/bias_weight/part_0/Ftrl" + } + } + } +} +node { + name: "save/RestoreV2_5/shape_and_slices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 1 + } + } + string_val: "1 0,1" + } + } + } +} +node { + name: "save/RestoreV2_5" + op: "RestoreV2" + input: "save/Const" + input: "save/RestoreV2_5/tensor_names" + input: "save/RestoreV2_5/shape_and_slices" + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "dtypes" + value { + list { + type: DT_FLOAT + } + } + } +} +node { + name: "save/Assign_5" + op: "Assign" + input: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl" + input: "save/RestoreV2_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/RestoreV2_6/tensor_names" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 1 + } + } + string_val: "linear/bias_weight/d/linear/bias_weight/part_0/Ftrl_1" + } + } + } +} +node { + name: "save/RestoreV2_6/shape_and_slices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 1 + } + } + string_val: "1 0,1" + } + } + } +} +node { + name: "save/RestoreV2_6" + op: "RestoreV2" + input: "save/Const" + input: "save/RestoreV2_6/tensor_names" + input: "save/RestoreV2_6/shape_and_slices" + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "dtypes" + value { + list { + type: DT_FLOAT + } + } + } +} +node { + name: "save/Assign_6" + op: "Assign" + input: "linear/binary_logistic_head/linear/bias_weight/part_0/Ftrl_1" + input: "save/RestoreV2_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@linear/bias_weight/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/restore_shard" + op: "NoOp" + input: "^save/Assign" + input: "^save/Assign_1" + input: "^save/Assign_2" + input: "^save/Assign_3" + input: "^save/Assign_4" + input: "^save/Assign_5" + input: "^save/Assign_6" +} +node { + name: "save/restore_all" + op: "NoOp" + input: "^save/restore_shard" +} +versions { + producer: 22 +} diff --git a/examples/edge_intelligence/trained_models/tensorflow_model/model.ckpt-1.data-00000-of-00001 b/examples/edge_intelligence/trained_models/tensorflow_model/model.ckpt-1.data-00000-of-00001 new file mode 100644 index 00000000..5423af7a Binary files /dev/null and b/examples/edge_intelligence/trained_models/tensorflow_model/model.ckpt-1.data-00000-of-00001 differ diff --git a/examples/edge_intelligence/trained_models/tensorflow_model/model.ckpt-1.index b/examples/edge_intelligence/trained_models/tensorflow_model/model.ckpt-1.index new file mode 100644 index 00000000..05b90e9c Binary files /dev/null and b/examples/edge_intelligence/trained_models/tensorflow_model/model.ckpt-1.index differ diff --git a/examples/edge_intelligence/trained_models/tensorflow_model/model.ckpt-1.meta b/examples/edge_intelligence/trained_models/tensorflow_model/model.ckpt-1.meta new file mode 100644 index 00000000..306de4a9 Binary files /dev/null and b/examples/edge_intelligence/trained_models/tensorflow_model/model.ckpt-1.meta differ diff --git a/examples/edge_intelligence/trained_models/tensorflow_model/model.ckpt-2000.data-00000-of-00001 b/examples/edge_intelligence/trained_models/tensorflow_model/model.ckpt-2000.data-00000-of-00001 new file mode 100644 index 00000000..9fe131a6 Binary files /dev/null and b/examples/edge_intelligence/trained_models/tensorflow_model/model.ckpt-2000.data-00000-of-00001 differ diff --git a/examples/edge_intelligence/trained_models/tensorflow_model/model.ckpt-2000.index b/examples/edge_intelligence/trained_models/tensorflow_model/model.ckpt-2000.index new file mode 100644 index 00000000..b15b4cd5 Binary files /dev/null and b/examples/edge_intelligence/trained_models/tensorflow_model/model.ckpt-2000.index differ diff --git a/examples/edge_intelligence/trained_models/tensorflow_model/model.ckpt-2000.meta b/examples/edge_intelligence/trained_models/tensorflow_model/model.ckpt-2000.meta new file mode 100644 index 00000000..306de4a9 Binary files /dev/null and b/examples/edge_intelligence/trained_models/tensorflow_model/model.ckpt-2000.meta differ diff --git a/examples/edge_intelligence/trained_models/windmill_tf_model.py b/examples/edge_intelligence/trained_models/windmill_tf_model.py new file mode 100644 index 00000000..a5d27423 --- /dev/null +++ b/examples/edge_intelligence/trained_models/windmill_tf_model.py @@ -0,0 +1,91 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +import os +import numpy as np +import tensorflow as tf + +# Data sets +TRAINING_SET = "windmill_training.csv" # file used for training the tensorflow model +TEST_SET = "windmill_test.csv" # file used for testing the accuracy of trained model + +def main(): + + # Load datasets for training + training_set = tf.contrib.learn.datasets.base.load_csv_with_header( + filename=TRAINING_SET, + target_dtype=np.int, + features_dtype=np.float32) + + test_set = tf.contrib.learn.datasets.base.load_csv_with_header( + filename=TEST_SET, + target_dtype=np.int, + features_dtype=np.float32) + + # Specify that all features have real-value data + feature_columns = [tf.contrib.layers.real_valued_column("", dimension=1)] + + + classifier = tf.contrib.learn.LinearClassifier(feature_columns=feature_columns, + model_dir="PATH_TO_SAVE_TRAINED_MODEL") # Enter the path where to save the model + + # Define the training inputs + def get_train_inputs(): + x = tf.constant(training_set.data) + y = tf.constant(training_set.target) + return x, y + + # Fit model. + classifier.fit(input_fn=get_train_inputs, steps=2000) + + # Define the test inputs + def get_test_inputs(): + x = tf.constant(test_set.data) + y = tf.constant(test_set.target) + return x, y + + # Evaluate accuracy. + accuracy_score = classifier.evaluate(input_fn=get_test_inputs, + steps=1)["accuracy"] + + print("\nTest Accuracy: {0:f}\n".format(accuracy_score)) + + # New data test + def new_data(): + return np.array([22], dtype=np.float32) + + predictions = list(classifier.predict_classes(input_fn=new_data)) + + print("New data prediction:{}\n".format(predictions)) + +if __name__ == "__main__": + main() diff --git a/examples/edge_intelligence/trained_models/windmill_tf_test.csv b/examples/edge_intelligence/trained_models/windmill_tf_test.csv new file mode 100644 index 00000000..1bfda410 --- /dev/null +++ b/examples/edge_intelligence/trained_models/windmill_tf_test.csv @@ -0,0 +1,31 @@ +30,1 +12.16666667,0 +11.83333333,0 +13,0 +13.16666667,0 +14.66666667,0 +14.16666667,0 +12.66666667,0 +11.66666667,0 +10.5,0 +11.5,0 +11,0 +12,0 +12.83333333,1 +13.33333333,1 +12.83333333,0 +12.5,0 +12,0 +10.5,0 +12.66666667,0 +12,0 +13.33333333,0 +13.33333333,0 +11.16666667,0 +12.16666667,0 +12.5,0 +12.83333333,0 +12,0 +12.5,0 +12,0 +12.5,1 diff --git a/examples/edge_intelligence/trained_models/windmill_tf_training.csv b/examples/edge_intelligence/trained_models/windmill_tf_training.csv new file mode 100644 index 00000000..5caa0123 --- /dev/null +++ b/examples/edge_intelligence/trained_models/windmill_tf_training.csv @@ -0,0 +1,121 @@ +120,1 +7.333333333,0 +13,0 +12.83333333,0 +11,1 +11.33333333,0 +11,0 +10.83333333,0 +12.16666667,0 +12.16666667,0 +12.33333333,0 +12.33333333,0 +10.33333333,1 +10,0 +12.33333333,0 +9.666666667,1 +12.5,0 +12.33333333,0 +12.83333333,0 +12.33333333,0 +12.66666667,1 +12.83333333,0 +12.5,0 +13.16666667,0 +12.66666667,0 +14,0 +13.16666667,0 +13,0 +15,1 +15,1 +16.33333333,1 +15.5,1 +16,1 +15.16666667,1 +16.83333333,1 +16.83333333,1 +16.83333333,1 +16.66666667,1 +16.83333333,1 +16.16666667,1 +16.83333333,1 +13,0 +14.33333333,1 +14.5,0 +13.83333333,0 +15.33333333,1 +14.5,0 +14,0 +15.33333333,1 +15,1 +14.16666667,0 +15,1 +14.83333333,0 +12.83333333,0 +13.83333333,1 +13.83333333,0 +13.16666667,0 +13.83333333,0 +14.66666667,0 +14,1 +14,0 +15.5,1 +14,0 +14,0 +13.83333333,0 +12.83333333,0 +15,1 +11.5,0 +14.16666667,0 +14.16666667,0 +14.83333333,1 +14.33333333,0 +14.83333333,0 +13.66666667,0 +14.33333333,0 +14.16666667,0 +13.33333333,0 +13.66666667,0 +13.83333333,0 +12.83333333,0 +13.33333333,0 +13.83333333,0 +15.16666667,1 +14.5,0 +14.5,0 +13.5,0 +12.16666667,0 +12.5,1 +12.83333333,0 +14.33333333,1 +13.66666667,0 +14.16666667,0 +14.33333333,0 +13.33333333,1 +13.33333333,0 +14,0 +13,0 +13.83333333,1 +13.16666667,0 +13.16666667,0 +12.83333333,0 +13.33333333,0 +13.33333333,0 +13.66666667,0 +12.16666667,0 +11.83333333,1 +14,0 +13.66666667,0 +13.33333333,0 +13.66666667,1 +12.33333333,0 +13.33333333,0 +13,0 +14.33333333,0 +13.16666667,0 +13.83333333,0 +13.5,0 +12.83333333,0 +12.33333333,1 +13.16666667,0 +12.5,0 diff --git a/examples/edge_intelligence/windmill_graphite_pfa.py b/examples/edge_intelligence/windmill_graphite_pfa.py new file mode 100755 index 00000000..730aaf9d --- /dev/null +++ b/examples/edge_intelligence/windmill_graphite_pfa.py @@ -0,0 +1,278 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +# This example depicts how edge component can be used to take actions locally based on pfa model +# and actions can then be send to device using actuator_udm method defined here, which is currently just printing +# the returned value is from PFAComponent as actions. Only the gateway metrics are being published to Graphite DCC. + +import pint +import math +import Queue + +from linux_metrics import cpu_stat, mem_stat + +from liota.dccs.graphite import Graphite +from liota.entities.metrics.metric import Metric +from liota.entities.devices.sensor_tag import Sensors, SensorTagCollector +from liota.entities.edge_systems.dell5k_edge_system import Dell5KEdgeSystem +from liota.dcc_comms.socket_comms import SocketDccComms +from liota.dccs.dcc import RegistrationFailure +from liota.edge_component.pfa_component import PFAComponent + +# getting values from conf file +config = {} +execfile('../sampleProp.conf', config) + +# create a pint unit registry +ureg = pint.UnitRegistry() + +rpm_model_queue = Queue.Queue() + +def read_cpu_procs(): + return cpu_stat.procs_running() + + +def read_cpu_utilization(sample_duration_sec=1): + cpu_pcts = cpu_stat.cpu_percents(sample_duration_sec) + return round((100 - cpu_pcts['idle']), 2) + + +def read_mem_free(): + total_mem = round(mem_stat.mem_stats()[1], 4) + free_mem = round(mem_stat.mem_stats()[3], 4) + mem_free_percent = ((total_mem - free_mem) / total_mem) * 100 + return round(mem_free_percent, 2) + + +def get_ambient_temperature(sensor_tag_collector): + return sensor_tag_collector.get_temperature()[0] + + +def get_relative_humidity(sensor_tag_collector): + return sensor_tag_collector.get_humidity()[1] + + +def get_pressure(sensor_tag_collector): + # 1 millibar = 100 Pascal + return sensor_tag_collector.get_barometer()[1] * 100 + + +def get_light_level(sensor_tag_collector): + return sensor_tag_collector.get_light_level() + + +def get_vibration_level(sensor_tag_collector): + # Accelerometer x,y,z in g + x, y, z = sensor_tag_collector.get_accelerometer() + # Magnitude of acceleration + # ∣a⃗∣=√ (x*x+y*y+z*z) + vib = math.sqrt((x * x + y * y + z * z)) + return vib + + +def get_rpm(sensor_tag_collector): + # RPM of Z-axis + # Average of 5 samples + _rpm_list = [] + while True: + if len(_rpm_list) == 5: + rpm = 0 + for _ in _rpm_list: + rpm += _ + rpm = int(rpm / 5) + break + else: + z_degree = sensor_tag_collector.get_gyroscope()[2] + # (°/s to RPM) + _rpm_list.append(int((abs(z_degree) * 0.16667))) + rpm_model_queue.put(rpm) + return rpm + +# we keep metric in queue and get one by one from the queue +def get_rpm_for_model(): + return rpm_model_queue.get(block=True) + +# actuator_udm can be used to pass on the value to the actuator, as of now we are printing them +def actuator_udm(value): + print value + + +# --------------------------------------------------------------------------------------- +# In this example, we demonstrate how metrics collected from a SensorTag device over BLE +# can be directed to graphite data center component using Liota. +# The program illustrates the ease of use Liota brings to IoT application developers. + +if __name__ == '__main__': + + # create a data center object, graphite in this case, using websocket as a transport layer + graphite = Graphite(SocketDccComms(ip=config['GraphiteIP'], + port=config['GraphitePort'])) + + try: + # create a System object encapsulating the particulars of a IoT System + # argument is the name of this IoT System + edge_system = Dell5KEdgeSystem(config['EdgeSystemName']) + + # resister the IoT System with the graphite instance + # this call creates a representation (a Resource) in graphite for this IoT System with the name given + reg_edge_system = graphite.register(edge_system) + + # Operational metrics of EdgeSystem + cpu_utilization_metric = Metric( + name="windmill.CPU_Utilization", + unit=None, + interval=10, + aggregation_size=2, + sampling_function=read_cpu_utilization + ) + reg_cpu_utilization_metric = graphite.register(cpu_utilization_metric) + graphite.create_relationship(reg_edge_system, reg_cpu_utilization_metric) + # call to start collecting values from the device or system and sending to the data center component + reg_cpu_utilization_metric.start_collecting() + + cpu_procs_metric = Metric( + name="windmill.CPU_Process", + unit=None, + interval=6, + aggregation_size=8, + sampling_function=read_cpu_procs + ) + reg_cpu_procs_metric = graphite.register(cpu_procs_metric) + graphite.create_relationship(reg_edge_system, reg_cpu_procs_metric) + reg_cpu_procs_metric.start_collecting() + + mem_free_metric = Metric( + name="windmill.Memory_Free", + unit=None, + interval=10, + sampling_function=read_mem_free + ) + reg_mem_free_metric = graphite.register(mem_free_metric) + graphite.create_relationship(reg_edge_system, reg_mem_free_metric) + reg_mem_free_metric.start_collecting() + + # Connects to the SensorTag device over BLE + sensor_tag_collector = SensorTagCollector(device_name=config['DeviceName'], device_mac=config['DeviceMac'], + sampling_interval_sec=1, retry_interval_sec=5, + sensors=[Sensors.TEMPERATURE, Sensors.HUMIDITY, Sensors.BAROMETER, + Sensors.LIGHTMETER, + Sensors.ACCELEROMETER, Sensors.GYROSCOPE]) + sensor_tag = sensor_tag_collector.get_sensor_tag() + # Registering SensorTagDevice with graphite + reg_sensor_tag = graphite.register(sensor_tag) + graphite.create_relationship(reg_edge_system, reg_sensor_tag) + + temperature_metric = Metric( + name="windmill.AmbientTemperature", + unit=ureg.degC, + interval=0, + aggregation_size=1, + sampling_function=lambda: get_ambient_temperature(sensor_tag_collector) + ) + reg_temperature_metric = graphite.register(temperature_metric) + graphite.create_relationship(reg_sensor_tag, reg_temperature_metric) + reg_temperature_metric.start_collecting() + + humidity_metric = Metric( + name="windmill.RelativeHumidity", + unit=None, + interval=0, + aggregation_size=1, + sampling_function=lambda: get_relative_humidity(sensor_tag_collector) + ) + reg_humidity_metric = graphite.register(humidity_metric) + graphite.create_relationship(reg_sensor_tag, reg_humidity_metric) + reg_humidity_metric.start_collecting() + + pressure_metric = Metric( + name="windmill.Pressure", + unit=ureg.Pa, + interval=0, + aggregation_size=1, + sampling_function=lambda: get_pressure(sensor_tag_collector) + ) + reg_pressure_metric = graphite.register(pressure_metric) + graphite.create_relationship(reg_sensor_tag, reg_pressure_metric) + reg_pressure_metric.start_collecting() + + light_metric = Metric( + name="windmill.LightLevel", + unit=ureg.lx, + interval=0, + aggregation_size=1, + sampling_function=lambda: get_light_level(sensor_tag_collector) + ) + reg_light_metric = graphite.register(light_metric) + graphite.create_relationship(reg_sensor_tag, reg_light_metric) + reg_light_metric.start_collecting() + + vibration_metric = Metric( + name="windmill.Vibration", + unit=None, + interval=0, + aggregation_size=1, + sampling_function=lambda: get_vibration_level(sensor_tag_collector) + ) + reg_vibration_metric = graphite.register(vibration_metric) + graphite.create_relationship(reg_sensor_tag, reg_vibration_metric) + reg_vibration_metric.start_collecting() + + rpm_metric = Metric( + name="windmill.RPM", + unit=None, + interval=0, + aggregation_size=1, + sampling_function=lambda: get_rpm(sensor_tag_collector) + ) + reg_rpm_metric = graphite.register(rpm_metric) + graphite.create_relationship(reg_sensor_tag, reg_rpm_metric) + reg_rpm_metric.start_collecting() + pfa_rpm_metric = Metric( + name="windmill.RPM", + unit=None, + interval=0, + aggregation_size=1, + sampling_function=get_rpm_for_model + ) + # ModelPath can be edited in the sampleProp.conf file + # pass value to actuator as of now the actuator_udm prints the value on the console + # PFA edge component is a part of edge intelligence and analytics for Liota, uses pfa model for analytics. + + edge_component = PFAComponent(config['ModelPath'], + actuator_udm=actuator_udm) + + pfa_reg_rpm_metric = edge_component.register(pfa_rpm_metric) + pfa_reg_rpm_metric.start_collecting() + + except RegistrationFailure: + print "Registration to graphite failed" + sensor_tag_collector.stop() diff --git a/examples/edge_intelligence/windmill_graphite_rule_edge.py b/examples/edge_intelligence/windmill_graphite_rule_edge.py new file mode 100755 index 00000000..d361c174 --- /dev/null +++ b/examples/edge_intelligence/windmill_graphite_rule_edge.py @@ -0,0 +1,139 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +# This example depicts how edge component can be used to take actions locally based on a rule defined +# and actions can then be send to device using actuator_udm method defined here, which is currently just printing +# the returned value is from RuleEdgeComponent as actions. Only the gateway metrics are being published to Graphite DCC. + +from linux_metrics import cpu_stat, mem_stat +from liota.dccs.graphite import Graphite +from liota.dcc_comms.socket_comms import SocketDccComms +from liota.entities.metrics.metric import Metric +from liota.dccs.dcc import RegistrationFailure +from liota.edge_component.rule_edge_component import RuleEdgeComponent +from liota.entities.edge_systems.dell5k_edge_system import Dell5KEdgeSystem +import random + +config = {} +execfile('../sampleProp.conf', config) + +def read_cpu_procs(): + return cpu_stat.procs_running() + +def read_cpu_utilization(sample_duration_sec=1): + cpu_pcts = cpu_stat.cpu_percents(sample_duration_sec) + return round((100 - cpu_pcts['idle']), 2) + +def read_mem_free(): + total_mem = round(mem_stat.mem_stats()[1], 4) + free_mem = round(mem_stat.mem_stats()[3], 4) + mem_free_percent = ((total_mem - free_mem) / total_mem) * 100 + return round(mem_free_percent, 2) + +# simulating windmill RPM which is a device connected to Edge. +def get_rpm(): + return random.randint(10,30) + +# actuator_udm can be used to pass on the value to the actuator, as of now we are printing them +def actuator_udm(value): + print value + +if __name__ == '__main__': + + graphite = Graphite(SocketDccComms(ip=config['GraphiteIP'],port=config['GraphitePort'])) + + try: + # create a System object encapsulating the particulars of a IoT System + # argument is the name of this IoT System + edge_system = Dell5KEdgeSystem(config['EdgeSystemName']) + + # resister the IoT System with the graphite instance + # this call creates a representation (a Resource) in graphite for this IoT System with the name given + reg_edge_system = graphite.register(edge_system) + + # Operational metrics of EdgeSystem + cpu_utilization_metric = Metric( + name="windmill.CPU_Utilization", + unit=None, + interval=10, + aggregation_size=2, + sampling_function=read_cpu_utilization + ) + reg_cpu_utilization_metric = graphite.register(cpu_utilization_metric) + graphite.create_relationship(reg_edge_system, reg_cpu_utilization_metric) + # call to start collecting values from the device or system and sending to the data center component + reg_cpu_utilization_metric.start_collecting() + + cpu_procs_metric = Metric( + name="windmill.CPU_Process", + unit=None, + interval=6, + aggregation_size=8, + sampling_function=read_cpu_procs + ) + reg_cpu_procs_metric = graphite.register(cpu_procs_metric) + graphite.create_relationship(reg_edge_system, reg_cpu_procs_metric) + reg_cpu_procs_metric.start_collecting() + + mem_free_metric = Metric( + name="windmill.Memory_Free", + unit=None, + interval=10, + sampling_function=read_mem_free + ) + reg_mem_free_metric = graphite.register(mem_free_metric) + graphite.create_relationship(reg_edge_system, reg_mem_free_metric) + reg_mem_free_metric.start_collecting() + + rule_rpm_metric = Metric( + name="windmill.RPM", + unit=None, + interval=1, + aggregation_size=1, + sampling_function=get_rpm + ) + + rpm_limit=20 + # Defined model rule + ModelRule = lambda value_collected : 1 if (value_collected>=rpm_limit) else 0 + exceed_limit = 1 #number of consecutive times a limit can be exceeded + + # pass value to actuator as of now the actuator_udm prints the value on the console + # RuleEdge component is a part of edge intelligence and analytics for Liota, uses python lambda fn. for analytics. + + edge_component = RuleEdgeComponent(ModelRule, exceed_limit, actuator_udm=actuator_udm) + rule_reg_rpm_metric = edge_component.register(rule_rpm_metric) + rule_reg_rpm_metric.start_collecting() + + + except RegistrationFailure: + print "Registration to graphite failed" diff --git a/examples/edge_intelligence/windmill_graphite_sklearn_edge.py b/examples/edge_intelligence/windmill_graphite_sklearn_edge.py new file mode 100755 index 00000000..de529d35 --- /dev/null +++ b/examples/edge_intelligence/windmill_graphite_sklearn_edge.py @@ -0,0 +1,147 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +# This example depicts how edge component can be used to take actions locally based on sklearn model +# and actions can then be send to device using actuator_udm method defined here, which is currently just printing +# the returned value is from SKLearnEdgeComponent as actions. Only the gateway metrics are being published to Graphite DCC. + +import pint +import math +import Queue + +from liota.dccs.graphite import Graphite +from liota.entities.metrics.metric import Metric +from liota.entities.devices.sensor_tag import Sensors, SensorTagCollector +from liota.entities.edge_systems.dell5k_edge_system import Dell5KEdgeSystem +from liota.dcc_comms.socket_comms import SocketDccComms +from liota.dccs.dcc import RegistrationFailure +from liota.edge_component.sklearn_edge_component import SKLearnEdgeComponent + +# getting values from conf file +config = {} +execfile('../sampleProp.conf', config) + +# create a pint unit registry +ureg = pint.UnitRegistry() + +rpm_model_queue = Queue.Queue() + +def get_rpm(sensor_tag_collector): + # RPM of Z-axis + # Average of 5 samples + _rpm_list = [] + while True: + if len(_rpm_list) == 5: + rpm = 0 + for _ in _rpm_list: + rpm += _ + rpm = int(rpm / 5) + break + else: + z_degree = sensor_tag_collector.get_gyroscope()[2] + # (°/s to RPM) + _rpm_list.append(int((abs(z_degree) * 0.16667))) + rpm_model_queue.put(rpm) + return rpm + +# we keep metric in queue and get one by one from the queue +def get_rpm_for_model(): + return rpm_model_queue.get(block=True) + +# actuator_udm can be used to pass on the value to the actuator, as of now we are printing them +def actuator_udm(value): + print value + + +# --------------------------------------------------------------------------------------- +# In this example, we demonstrate how metrics collected from a SensorTag device over BLE +# can be directed to graphite data center component using Liota. +# The program illustrates the ease of use Liota brings to IoT application developers. + +if __name__ == '__main__': + + # create a data center object, graphite in this case, using websocket as a transport layer + graphite = Graphite(SocketDccComms(ip=config['GraphiteIP'], + port=config['GraphitePort'])) + + try: + # create a System object encapsulating the particulars of a IoT System + # argument is the name of this IoT System + edge_system = Dell5KEdgeSystem(config['EdgeSystemName']) + + # resister the IoT System with the graphite instance + # this call creates a representation (a Resource) in graphite for this IoT System with the name given + reg_edge_system = graphite.register(edge_system) + + # Connects to the SensorTag device over BLE + sensor_tag_collector = SensorTagCollector(device_name=config['DeviceName'], device_mac=config['DeviceMac'], + sampling_interval_sec=1, retry_interval_sec=5, + sensors=[Sensors.TEMPERATURE, Sensors.HUMIDITY, Sensors.BAROMETER, + Sensors.LIGHTMETER, + Sensors.ACCELEROMETER, Sensors.GYROSCOPE]) + sensor_tag = sensor_tag_collector.get_sensor_tag() + # Registering SensorTagDevice with graphite + reg_sensor_tag = graphite.register(sensor_tag) + graphite.create_relationship(reg_edge_system, reg_sensor_tag) + + rpm_metric = Metric( + name="windmill.RPM", + unit=None, + interval=0, + aggregation_size=1, + sampling_function=lambda: get_rpm(sensor_tag_collector) + ) + reg_rpm_metric = graphite.register(rpm_metric) + graphite.create_relationship(reg_sensor_tag, reg_rpm_metric) + reg_rpm_metric.start_collecting() + + sklearn_rpm_metric = Metric( + name="windmill.RPM", + unit=None, + interval=10, + aggregation_size=1, + sampling_function=get_rpm_for_model + ) + + # ModelPath can be edited in the sampleProp.conf file + # pass value to actuator as of now the actuator_udm prints the value on the console + # SKLearn edge component is a part of edge intelligence and analytics for Liota,uses scikit-learn trained model for analytics. + + edge_component = SKLearnEdgeComponent(config['ModelPath'], + actuator_udm=actuator_udm) + + sklearn_reg_rpm_metric = edge_component.register(sklearn_rpm_metric) + sklearn_reg_rpm_metric.start_collecting() + + except RegistrationFailure: + print "Registration to graphite failed" + sensor_tag_collector.stop() diff --git a/examples/edge_intelligence/windmill_graphite_tf_edge.py b/examples/edge_intelligence/windmill_graphite_tf_edge.py new file mode 100644 index 00000000..96cbc76c --- /dev/null +++ b/examples/edge_intelligence/windmill_graphite_tf_edge.py @@ -0,0 +1,145 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +# This example depicts how edge component can be used to take actions locally based on trained TensorFlow model +# and actions can then be send to device using actuator_udm method defined here, which is currently just printing +# the returned value is from TensorFlowEdgeComponent as actions. Only the gateway metrics are being published to Graphite DCC. + +import math +import random + +from linux_metrics import cpu_stat, mem_stat +from liota.dccs.graphite import Graphite +from liota.entities.metrics.metric import Metric +from liota.entities.edge_systems.dell5k_edge_system import Dell5KEdgeSystem +from liota.dcc_comms.socket_comms import SocketDccComms +from liota.dccs.dcc import RegistrationFailure +from liota.edge_component.tensorflow_edge_component import TensorFlowEdgeComponent +from liota.lib.utilities.utility import read_user_config + +# getting values from conf file +config = {} +execfile('../sampleProp.conf', config) + +def read_cpu_procs(): + return cpu_stat.procs_running() + +def read_cpu_utilization(sample_duration_sec=1): + cpu_pcts = cpu_stat.cpu_percents(sample_duration_sec) + return round((100 - cpu_pcts['idle']), 2) + +def read_mem_free(): + total_mem = round(mem_stat.mem_stats()[1], 4) + free_mem = round(mem_stat.mem_stats()[3], 4) + mem_free_percent = ((total_mem - free_mem) / total_mem) * 100 + return round(mem_free_percent, 2) + +# actuator_udm can be used to pass on the value to the actuator, as of now we are printing them +def actuator_udm(value): + print value + +# simulating windmill RPM which is a device connected to Edge. +def get_rpm(): + return random.randint(10,25) + +# --------------------------------------------------------------------------------------- +# In this example, we demonstrate how metrics collected from a SensorTag device over BLE +# can be directed to graphite data center component using Liota. +# The program illustrates the ease of use Liota brings to IoT application developers. + +if __name__ == '__main__': + + # create a data center object, graphite in this case, using websocket as a transport layer + graphite = Graphite(SocketDccComms(ip=config['GraphiteIP'], + port=config['GraphitePort'])) + + try: + # create a System object encapsulating the particulars of a IoT System + # argument is the name of this IoT System + edge_system = Dell5KEdgeSystem(config['EdgeSystemName']) + + # resister the IoT System with the graphite instance + # this call creates a representation (a Resource) in graphite for this IoT System with the name given + reg_edge_system = graphite.register(edge_system) + + # Operational metrics of EdgeSystem + cpu_utilization_metric = Metric( + name="windmill.CPU_Utilization", + unit=None, + interval=10, + aggregation_size=2, + sampling_function=read_cpu_utilization + ) + reg_cpu_utilization_metric = graphite.register(cpu_utilization_metric) + graphite.create_relationship(reg_edge_system, reg_cpu_utilization_metric) + # call to start collecting values from the device or system and sending to the data center component + reg_cpu_utilization_metric.start_collecting() + + cpu_procs_metric = Metric( + name="windmill.CPU_Process", + unit=None, + interval=6, + aggregation_size=8, + sampling_function=read_cpu_procs + ) + reg_cpu_procs_metric = graphite.register(cpu_procs_metric) + graphite.create_relationship(reg_edge_system, reg_cpu_procs_metric) + reg_cpu_procs_metric.start_collecting() + + mem_free_metric = Metric( + name="windmill.Memory_Free", + unit=None, + interval=10, + sampling_function=read_mem_free + ) + reg_mem_free_metric = graphite.register(mem_free_metric) + graphite.create_relationship(reg_edge_system, reg_mem_free_metric) + reg_mem_free_metric.start_collecting() + + tf_rpm_metric = Metric( + name="windmill.RPM", + unit=None, + interval=1, + aggregation_size=1, + sampling_function=get_rpm + ) + + # ModelPath can be edited in the sampleProp.conf file + # pass value to actuator as of now the actuator_udm prints the value on the console + # TensorFlow edge component is a part of edge intelligence and analytics for Liota, uses tensorflow trained model + # for analytics. + edge_component = TensorFlowEdgeComponent(config['ModelPath'], actuator_udm=actuator_udm) + tf_reg_rpm_metric = edge_component.register(tf_rpm_metric) + tf_reg_rpm_metric.start_collecting() + + except RegistrationFailure: + print "Registration to graphite failed" diff --git a/examples/sampleProp.conf b/examples/sampleProp.conf index 1906d364..bc82f6c4 100644 --- a/examples/sampleProp.conf +++ b/examples/sampleProp.conf @@ -1,7 +1,8 @@ -[DEFAULT] +#### [DEFAULT] #### EdgeSystemName = "EdgeSystem-Name" DeviceName = "Device-Name" +DeviceMac = "Device-Mac" MetricName = "Metric-Name" MetricWithOwnTsName = "Metric-With-Own-Ts-Name" BulkCollectedMetricName = "Bulk-Collected-Metric-Name" @@ -9,17 +10,21 @@ BulkCollectedMetricName = "Bulk-Collected-Metric-Name" SystemPropList = {"Country":"USA-G", "State":"California", "City":"Palo Alto", "Location":"VMware HQ", "Building":"Promontory H Lab", "Floor":"First Floor"} DevicePropList = {"Country":"USA-G", "State":"California", "City":"Palo Alto", "Location":"VMware HQ", "Building":"Promontory H Lab", "Floor":"First Floor"} -#### [IOTCC] #### +#### [GENERIC_WEBSOCKET] #### WebSocketUrl = "Websocket-address-url" IotCCUID = "Username" IotCCPassword = "Password" WebsocketCaCertFile = "/etc/liota/websocket/cacert.pem" -VerifyServerCert = True -ClientKeyFile = None +VerifyServerCert = True +ClientKeyFile = None ClientCertFile = None #### [GRAPHITE] #### -GraphiteIP = "Graphite-IP" -GraphitePort = None +GraphiteIP = "GraphiteIP" +GraphitePort = GraphitePort + +#### [EDGE_INTELLIGENCE] #### + +ModelPath = "ModelPath" diff --git a/liota/edge_component/__init__.py b/liota/edge_component/__init__.py new file mode 100755 index 00000000..4badd4a2 --- /dev/null +++ b/liota/edge_component/__init__.py @@ -0,0 +1,31 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# diff --git a/liota/edge_component/edge_component.py b/liota/edge_component/edge_component.py new file mode 100755 index 00000000..6e46f446 --- /dev/null +++ b/liota/edge_component/edge_component.py @@ -0,0 +1,102 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +import os +import logging +from abc import ABCMeta, abstractmethod +import types + +from liota.entities.entity import Entity +from liota.entities.metrics.registered_metric import RegisteredMetric + +log = logging.getLogger(__name__) + +class EdgeComponent: + + """ + Abstract base class for all EdgeComponents. + """ + __metaclass__ = ABCMeta + + @abstractmethod + def __init__(self, model_path, actuator_udm): + if not isinstance(actuator_udm, types.FunctionType): + raise TypeError("actuator_udm must be of function type.") + self.model_path = model_path + self.actuator_udm = actuator_udm + + # ----------------------------------------------------------------------- + # Implement this method in subclasses and do actual registration. + # + # This method should return a RegisteredEntity if successful, or raise + # an exception if failed. Call this method from subclasses for a type + # check. + # + + @abstractmethod + def register(self, entity_obj): + if not isinstance(entity_obj, Entity): + log.error("Entity object is expected.") + raise TypeError("Entity object is expected.") + + @abstractmethod + def create_relationship(self, reg_entity_parent, reg_entity_child): + pass + + @abstractmethod + def _format_data(self, reg_metric): + pass + + @abstractmethod + def process(self, message): + pass + + def publish(self, reg_metric): + if not isinstance(reg_metric, RegisteredMetric): + log.error("RegisteredMetric object is expected.") + raise TypeError("RegisteredMetric object is expected.") + self.process(self._format_data(reg_metric)) + + @abstractmethod + def unregister(self, entity_obj): + if not isinstance(entity_obj, Entity): + raise TypeError + + @abstractmethod + def build_model(self): + pass + + @abstractmethod + def load_model(self): + pass + +class RegistrationFailure(Exception): pass diff --git a/liota/edge_component/pfa_component.py b/liota/edge_component/pfa_component.py new file mode 100755 index 00000000..e6aa0c01 --- /dev/null +++ b/liota/edge_component/pfa_component.py @@ -0,0 +1,90 @@ + +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +import logging +import os +from liota.edge_component.edge_component import EdgeComponent +import csv +from liota.entities.metrics.metric import Metric +from liota.entities.metrics.registered_metric import RegisteredMetric +from liota.entities.registered_entity import RegisteredEntity +import titus.prettypfa +import json +from titus.genpy import PFAEngine + +log = logging.getLogger(__name__) + + +class PFAComponent(EdgeComponent): + + def __init__(self, model_path, actuator_udm): + super(PFAComponent, self).__init__(model_path, actuator_udm) + if not os.path.exists(model_path): + raise IOError("File does not exist: {} ".format(model_path)) + self.model = None + self.load_model() + + def load_model(self): + log.info("Loading model..") + self.model, = PFAEngine.fromJson(json.load(open(self.model_path))) + + def register(self, entity_obj): + if isinstance(entity_obj, Metric): + return RegisteredMetric(entity_obj, self, None) + else: + return RegisteredEntity(entity_obj, self, None) + + def create_relationship(self, reg_entity_parent, reg_entity_child): + pass + + def process(self,message): + self.actuator_udm(self.model.action(message)) + + def _format_data(self, reg_metric): + met_cnt = reg_metric.values.qsize() + if met_cnt == 0: + return + for _ in range(met_cnt): + metric_value = reg_metric.values.get(block=True) + if metric_value is not None: + # metric_value[1] as metric_value is a list having both timestamp and value + return metric_value[1] + + def set_properties(self, reg_entity, properties): + pass + + def unregister(self, entity_obj): + pass + + def build_model(self): + pass diff --git a/liota/edge_component/rule_edge_component.py b/liota/edge_component/rule_edge_component.py new file mode 100755 index 00000000..7a02fe69 --- /dev/null +++ b/liota/edge_component/rule_edge_component.py @@ -0,0 +1,101 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +import logging +import types + +from liota.edge_component.edge_component import EdgeComponent +from liota.entities.registered_entity import RegisteredEntity +from liota.entities.edge_systems.edge_system import EdgeSystem +from liota.entities.devices.device import Device +from liota.entities.metrics.metric import Metric +from liota.entities.metrics.registered_metric import RegisteredMetric + +log = logging.getLogger(__name__) + +class RuleEdgeComponent(EdgeComponent): + def __init__(self, model_rule, exceed_limit_consecutive, actuator_udm): + if model_rule is None: + raise TypeError("Model rule must be specified.") + + if not isinstance(model_rule, types.LambdaType): + raise TypeError("Model rule must be a lambda function.") + + if model_rule.__name__ != "": + raise TypeError("Model rule must be a lambda function.") + + if type(exceed_limit_consecutive) is not int: + raise ValueError("exceed_limit should be a integer value.") + + self.model_rule = model_rule + self.actuator_udm = actuator_udm + self.exceed_limit = exceed_limit_consecutive + self.counter = 0 + + def register(self, entity_obj): + if isinstance(entity_obj, Metric): + return RegisteredMetric(entity_obj, self, None) + else: + return RegisteredEntity(entity_obj, self, None) + + def create_relationship(self, reg_entity_parent, reg_entity_child): + reg_entity_child.parent = reg_entity_parent + + def process(self, message): + if not isinstance(self.actuator_udm, types.FunctionType): + raise TypeError("actuator_udm must be of function type.") + result = self.model_rule(message) + self.counter = 0 if(result==0) else self.counter+1 + if(self.counter>=self.exceed_limit): + self.counter=0 + self.actuator_udm(1) + else: + self.actuator_udm(0) + + def _format_data(self, reg_metric): + met_cnt = reg_metric.values.qsize() + if met_cnt == 0: + return + for _ in range(met_cnt): + metric_value = reg_metric.values.get(block=True) + if metric_value is not None: + # metric_value[1] as metric_value is a list having both timestamp and value + return metric_value[1] + + def build_model(self): + pass + + def load_model(self): + pass + + def unregister(self): + pass diff --git a/liota/edge_component/sklearn_edge_component.py b/liota/edge_component/sklearn_edge_component.py new file mode 100755 index 00000000..5b264c23 --- /dev/null +++ b/liota/edge_component/sklearn_edge_component.py @@ -0,0 +1,86 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +import json +import logging +import os +import numpy as np +from sklearn.externals import joblib + +from liota.edge_component.edge_component import EdgeComponent +from liota.entities.metrics.metric import Metric +from liota.entities.metrics.registered_metric import RegisteredMetric +from liota.entities.registered_entity import RegisteredEntity +import types + +log = logging.getLogger(__name__) + +class SKLearnEdgeComponent(EdgeComponent): + + def __init__(self, model_path, actuator_udm): + super(SKLearnEdgeComponent, self).__init__(model_path, actuator_udm) + if not os.path.exists(model_path): + raise IOError("File does not exist: {} ".format(model_path)) + self.model = None + self.load_model() + + def load_model(self): + log.info("Loading model..") + self.model = joblib.load(self.model_path) + + def register(self, entity_obj): + if isinstance(entity_obj, Metric): + return RegisteredMetric(entity_obj, self, None) + else: + return RegisteredEntity(entity_obj, self, None) + + def create_relationship(self, reg_entity_parent, reg_entity_child): + pass + + def process(self, message): + self.actuator_udm(self.model.predict(message)[0]) + + def _format_data(self, reg_metric): + met_cnt = reg_metric.values.qsize() + if met_cnt == 0: + return + for _ in range(met_cnt): + metric_value = reg_metric.values.get(block=True) + if metric_value is not None: + # metric_value[1] as metric_value is a list having both timestamp and value + return np.array([metric_value[1]]).reshape(-1, 1) + + def unregister(self, entity_obj): + pass + + def build_model(self): + pass diff --git a/liota/edge_component/tensorflow_edge_component.py b/liota/edge_component/tensorflow_edge_component.py new file mode 100755 index 00000000..449824f8 --- /dev/null +++ b/liota/edge_component/tensorflow_edge_component.py @@ -0,0 +1,93 @@ +# -*- coding: utf-8 -*- # +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +import os +import types +import tensorflow as tf +import logging +import numpy as np + +from liota.edge_component.edge_component import EdgeComponent +from liota.entities.registered_entity import RegisteredEntity +from liota.entities.edge_systems.edge_system import EdgeSystem +from liota.entities.devices.device import Device +from liota.entities.metrics.metric import Metric +from liota.entities.metrics.registered_metric import RegisteredMetric + +log = logging.getLogger(__name__) + +class TensorFlowEdgeComponent(EdgeComponent): + + def __init__(self, model_path, actuator_udm): + super(TensorFlowEdgeComponent, self).__init__(model_path, actuator_udm) + if not os.path.exists(model_path): + raise IOError("File does not exist: {} ".format(model_path)) + self.model = None + self.load_model(self.model_path) + + def load_model(self,model_path): + features = [""] + with tf.Session() as sess: + feature_cols = [tf.contrib.layers.real_valued_column(k, dimension=1) for k in features] + self.model = tf.contrib.learn.LinearClassifier(feature_columns=feature_cols, model_dir=self.model_path) + + def register(self, entity_obj): + if isinstance(entity_obj, Metric): + return RegisteredMetric(entity_obj, self, None) + else: + return RegisteredEntity(entity_obj, self, None) + + def create_relationship(self, reg_entity_parent, reg_entity_child): + reg_entity_child.parent = reg_entity_parent + + def input_fn(self, message): + return np.array([message], dtype=np.float32) + + def process(self, message): + prediction = list(self.model.predict_classes(input_fn=lambda:self.input_fn(message))) + self.actuator_udm(prediction[0]) + + def _format_data(self, reg_metric): + met_cnt = reg_metric.values.qsize() + if met_cnt == 0: + return + for _ in range(met_cnt): + metric_value = reg_metric.values.get(block=True) + if metric_value is not None: + # metric_value[1] as metric_value is a list having both timestamp and value + return metric_value[1] + + def unregister(self, entity_obj): + pass + + def build_model(self): + pass diff --git a/liota/entities/devices/windmill_simulated.py b/liota/entities/devices/windmill_simulated.py new file mode 100644 index 00000000..f8a4c609 --- /dev/null +++ b/liota/entities/devices/windmill_simulated.py @@ -0,0 +1,49 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +import random +from liota.entities.devices.device import Device +from liota.lib.utilities.utility import systemUUID + +class windmillSimulated(Device): + def __init__(self, name): + super(windmillSimulated, self).__init__( + name=name, + entity_id=systemUUID().get_uuid(name), + entity_type="windmillSimulated" + ) + + def get_rpm(self): + return random.randint(10,25) + + def get_vib(self): + return round(random.uniform(0.480,0.7),3) diff --git a/packages/examples/edge_intelligence/graphite_pfa_edge.py b/packages/examples/edge_intelligence/graphite_pfa_edge.py new file mode 100644 index 00000000..0d2f63a4 --- /dev/null +++ b/packages/examples/edge_intelligence/graphite_pfa_edge.py @@ -0,0 +1,125 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +import Queue + +from liota.core.package_manager import LiotaPackage +from liota.lib.utilities.utility import read_user_config + +dependencies = ["graphite", "examples/windmill_simulator"] + +rpm_queue = Queue.Queue() +action_taken = Queue.Queue() + +class PackageClass(LiotaPackage): + def create_udm(self, windmill_model): + + def get_rpm_windmill(): + rpm = windmill_model.get_rpm() + rpm_queue.put(rpm) + return rpm + + # using queue so that same values are for both edge_component and graphite + def get_windmill_rpm_edge(): + return rpm_queue.get(block=True) + + # you can write your own logic in this function in order to send value + # to device if needed, currently action is being published to Graphite DCC + def get_action(value): + action_taken.put(value) + + def get_action_taken(): + return action_taken.get(block=True) + + self.get_rpm_windmill = get_rpm_windmill + self.get_windmill_rpm_edge = get_windmill_rpm_edge + self.get_action = get_action + self.get_action_taken = get_action_taken + + def run(self, registry): + from liota.entities.metrics.metric import Metric + from liota.edge_component.pfa_component import PFAComponent + + config_path = registry.get("package_conf") + config = read_user_config(config_path + '/sampleProp.conf') + windmill_simulator = registry.get("windmill_simulator") + graphite = registry.get("graphite") + graphite_windmill = graphite.register(windmill_simulator) + + self.create_udm(windmill_model=windmill_simulator) + + pfa_edge_component = PFAComponent(config['ModelPath'], self.get_action) + + self.metrics = [] + + metric_name = "edge.rpm" + + rpm = Metric( + name = metric_name, + unit = None, + interval=1, + aggregation_size=1, + sampling_function=self.get_rpm_windmill + ) + + reg_windmill_rpm = graphite.register(rpm) + graphite.create_relationship(graphite_windmill, reg_windmill_rpm) + reg_windmill_rpm.start_collecting() + self.metrics.append(reg_windmill_rpm) + + pfa_rpm = Metric( + name = metric_name, + unit = None, + interval=1, + aggregation_size=1, + sampling_function=self.get_windmill_rpm_edge + ) + reg_rpm = pfa_edge_component.register(pfa_rpm) + reg_rpm.start_collecting() + self.metrics.append(reg_rpm) + + action_taken = Metric( + name = "edge.action", + unit = None, + interval=1, + aggregation_size=1, + sampling_function=self.get_action_taken + ) + + reg_windmill_action = graphite.register(action_taken) + graphite.create_relationship(graphite_windmill, reg_windmill_action) + reg_windmill_action.start_collecting() + self.metrics.append(reg_windmill_action) + + def clean_up(self): + for metric in self.metrics: + metric.stop_collecting() diff --git a/packages/examples/edge_intelligence/graphite_rule_edge_component.py b/packages/examples/edge_intelligence/graphite_rule_edge_component.py new file mode 100644 index 00000000..39dd5a81 --- /dev/null +++ b/packages/examples/edge_intelligence/graphite_rule_edge_component.py @@ -0,0 +1,125 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +import Queue + +from liota.core.package_manager import LiotaPackage + +dependencies = ["graphite", "examples/windmill_simulator"] + +vib_queue = Queue.Queue() +action_taken = Queue.Queue() + +class PackageClass(LiotaPackage): + def create_udm(self, windmill_model): + + def get_windmill_vib(): + vib = windmill_model.get_vib() + vib_queue.put(vib) + return vib + + def get_vib_windmill_edge(): + return vib_queue.get(block=True) + + # you can write your own logic in this function in order to send value + # to device if needed, currently action is being published to Graphite DCC + def get_action(value): + action_taken.put(value) + + def get_action_taken(): + return action_taken.get(block=True) + + self.get_windmill_vib = get_windmill_vib + self.get_vib_windmill_edge = get_vib_windmill_edge + self.get_action = get_action + self.get_action_taken = get_action_taken + + def run(self, registry): + from liota.entities.metrics.metric import Metric + from liota.edge_component.rule_edge_component import RuleEdgeComponent + + windmill_simulator = registry.get("windmill_simulator") + graphite = registry.get("graphite") + graphite_windmill = graphite.register(windmill_simulator) + + self.create_udm(windmill_model=windmill_simulator) + + vib_limit = 0.59 + ModelRule = lambda value_collected : 1 if (value_collected>=vib_limit) else 0 + exceed_limit = 1 + rule_edge_component = RuleEdgeComponent(ModelRule, exceed_limit, self.get_action) + + self.metrics = [] + + metric_name = "edge.vib" + + vib = Metric( + name = metric_name, + unit = None, + interval=1, + aggregation_size=1, + sampling_function=self.get_windmill_vib + ) + + reg_windmill_vib = graphite.register(vib) + graphite.create_relationship(graphite_windmill, reg_windmill_vib) + reg_windmill_vib.start_collecting() + self.metrics.append(reg_windmill_vib) + + rule_vib = Metric( + name = metric_name, + unit = None, + interval=1, + aggregation_size=1, + sampling_function=self.get_vib_windmill_edge + ) + + reg_vib = rule_edge_component.register(rule_vib) + reg_vib.start_collecting() + self.metrics.append(reg_vib) + + action_taken = Metric( + name = "edge.action", + unit = None, + interval=1, + aggregation_size=1, + sampling_function=self.get_action_taken + ) + + reg_windmill_action = graphite.register(action_taken) + graphite.create_relationship(graphite_windmill, reg_windmill_action) + reg_windmill_action.start_collecting() + self.metrics.append(reg_windmill_action) + + def clean_up(self): + for metric in self.metrics: + metric.stop_collecting() diff --git a/packages/examples/edge_intelligence/graphite_sklearn_edge.py b/packages/examples/edge_intelligence/graphite_sklearn_edge.py new file mode 100755 index 00000000..6084e27b --- /dev/null +++ b/packages/examples/edge_intelligence/graphite_sklearn_edge.py @@ -0,0 +1,126 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +import Queue + +from liota.core.package_manager import LiotaPackage +from liota.lib.utilities.utility import read_user_config + +dependencies = ["graphite", "examples/windmill_simulator"] + +rpm_queue = Queue.Queue() +action_taken = Queue.Queue() + +class PackageClass(LiotaPackage): + def create_udm(self, windmill_model): + + def get_rpm_windmill(): + rpm = windmill_model.get_rpm() + rpm_queue.put(rpm) + return rpm + + # using queue so that same values are for both edge_component and graphite + def get_windmill_rpm_edge(): + return rpm_queue.get(block=True) + + # you can write your own logic in this function in order to send value + # to device if needed, currently action is being published to Graphite DCC + def get_action(value): + action_taken.put(value) + + def get_action_taken(): + return action_taken.get(block=True) + + self.get_rpm_windmill = get_rpm_windmill + self.get_windmill_rpm_edge = get_windmill_rpm_edge + self.get_action = get_action + self.get_action_taken = get_action_taken + + def run(self, registry): + from liota.entities.metrics.metric import Metric + from liota.edge_component.sklearn_edge_component import SKLearnEdgeComponent + + config_path = registry.get("package_conf") + config = read_user_config(config_path + '/sampleProp.conf') + windmill_simulator = registry.get("windmill_simulator") + graphite = registry.get("graphite") + graphite_windmill = graphite.register(windmill_simulator) + + self.create_udm(windmill_model=windmill_simulator) + + # you can add ModelPath in sampleProp.conf file + sklearn_edge_component = SKLearnEdgeComponent(config['ModelPath'], self.get_action) + + self.metrics = [] + + metric_name = "edge.rpm" + + rpm = Metric( + name = metric_name, + unit = None, + interval=1, + aggregation_size=1, + sampling_function=self.get_rpm_windmill + ) + + reg_windmill_rpm = graphite.register(rpm) + graphite.create_relationship(graphite_windmill, reg_windmill_rpm) + reg_windmill_rpm.start_collecting() + self.metrics.append(reg_windmill_rpm) + + sklearn_rpm = Metric( + name = metric_name, + unit = None, + interval=1, + aggregation_size=1, + sampling_function=self.get_windmill_rpm_edge + ) + reg_rpm = sklearn_edge_component.register(sklearn_rpm) + reg_rpm.start_collecting() + self.metrics.append(reg_rpm) + + action_taken = Metric( + name = "edge.action", + unit = None, + interval=1, + aggregation_size=1, + sampling_function=self.get_action_taken + ) + + reg_windmill_action = graphite.register(action_taken) + graphite.create_relationship(graphite_windmill, reg_windmill_action) + reg_windmill_action.start_collecting() + self.metrics.append(reg_windmill_action) + + def clean_up(self): + for metric in self.metrics: + metric.stop_collecting() diff --git a/packages/examples/edge_intelligence/graphite_tensorflow_edge.py b/packages/examples/edge_intelligence/graphite_tensorflow_edge.py new file mode 100644 index 00000000..68388479 --- /dev/null +++ b/packages/examples/edge_intelligence/graphite_tensorflow_edge.py @@ -0,0 +1,127 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +import Queue + +from liota.core.package_manager import LiotaPackage +from liota.lib.utilities.utility import read_user_config + +dependencies = ["graphite", "examples/windmill_simulator"] + +rpm_queue = Queue.Queue() +action_taken = Queue.Queue() + +class PackageClass(LiotaPackage): + def create_udm(self, windmill_model): + + def get_windmill_rpm(): + rpm = windmill_model.get_rpm() + rpm_queue.put(rpm) + return rpm + + # using queue so that same values are for both edge_component and graphite + def get_rpm_windmill_edge(): + return rpm_queue.get(block=True) + + # you can write your own logic in this function in order to send value + # to device if needed, currently action is being published to Graphite DCC + def get_action(value): + action_taken.put(value) + + def get_action_taken(): + return action_taken.get(block=True) + + self.get_windmill_rpm = get_windmill_rpm + self.get_rpm_windmill_edge = get_rpm_windmill_edge + self.get_action = get_action + self.get_action_taken = get_action_taken + + def run(self, registry): + from liota.entities.metrics.metric import Metric + from liota.edge_component.tensorflow_edge_component import TensorFlowEdgeComponent + + config_path = registry.get("package_conf") + config = read_user_config(config_path + '/sampleProp.conf') + windmill_simulator = registry.get("windmill_simulator") + graphite = registry.get("graphite") + graphite_windmill = graphite.register(windmill_simulator) + + self.create_udm(windmill_model=windmill_simulator) + + # you can add ModelPath in sampleProp.conf file + tensorflow_edge_component = TensorFlowEdgeComponent(config['ModelPath'], self.get_action) + + self.metrics = [] + + metric_name = "edge.rpm" + + rpm = Metric( + name = metric_name, + unit = None, + interval=1, + aggregation_size=1, + sampling_function=self.get_windmill_rpm + ) + + reg_windmill_rpm = graphite.register(rpm) + graphite.create_relationship(graphite_windmill, reg_windmill_rpm) + reg_windmill_rpm.start_collecting() + self.metrics.append(reg_windmill_rpm) + + tensorflow_rpm = Metric( + name = metric_name, + unit = None, + interval=1, + aggregation_size=1, + sampling_function=self.get_rpm_windmill_edge + ) + + reg_rpm = tensorflow_edge_component.register(tensorflow_rpm) + reg_rpm.start_collecting() + self.metrics.append(reg_rpm) + + action_taken = Metric( + name = "edge.action", + unit = None, + interval=1, + aggregation_size=1, + sampling_function=self.get_action_taken + ) + + reg_windmill_action = graphite.register(action_taken) + graphite.create_relationship(graphite_windmill, reg_windmill_action) + reg_windmill_action.start_collecting() + self.metrics.append(reg_windmill_action) + + def clean_up(self): + for metric in self.metrics: + metric.stop_collecting() diff --git a/packages/examples/windmill_simulator.py b/packages/examples/windmill_simulator.py new file mode 100644 index 00000000..9e66ab6b --- /dev/null +++ b/packages/examples/windmill_simulator.py @@ -0,0 +1,55 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +from liota.core.package_manager import LiotaPackage +from liota.lib.utilities.utility import read_user_config + +dependencies = ["edge_systems/dell5k/edge_system"] + +class PackageClass(LiotaPackage): + + def run(self, registry): + from liota.entities.devices.windmill_simulated import windmillSimulated + + # Get values from configuration file + config_path = registry.get("package_conf") + config = read_user_config(config_path + '/sampleProp.conf') + + # initialize and run the physical model (simulated device) + windmill_simulator = windmillSimulated( + name=config['DeviceName'], + ) + + registry.register("windmill_simulator", windmill_simulator) + + def clean_up(self): + pass diff --git a/packages/sampleProp.conf b/packages/sampleProp.conf index 3c1c1948..edfff43c 100644 --- a/packages/sampleProp.conf +++ b/packages/sampleProp.conf @@ -22,8 +22,8 @@ ClientCertFile = None #### [GRAPHITE] #### -GraphiteIP = "Graphite-IP" -GraphitePort = None +GraphiteIP = "GraphiteIP" +GraphitePort = GraphitePort #### [GENERICMQTT] #### @@ -49,3 +49,6 @@ LivingRoomTemperatureTopic = "home/living-room/temperature" LivingRoomHumidityTopic = "home/living-room/humidity" LivingRoomLightTopic = "home/living-room/light" +#### [EDGE_INTELLIGENCE] #### + +ModelPath = "ModelPath" diff --git a/tests/unit/edge_intelligence/pfa_component_test.py b/tests/unit/edge_intelligence/pfa_component_test.py new file mode 100755 index 00000000..3ea403f4 --- /dev/null +++ b/tests/unit/edge_intelligence/pfa_component_test.py @@ -0,0 +1,64 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +import unittest +from liota.edge_component.pfa_component import PFAComponent + +def actuator_udm(): + pass + +ModelPath = "ModelPath" + +class TestPFAComponent(unittest.TestCase): + + def test_PFAComponent_fails_without_valid_ModelPath(self): + with self.assertRaises(Exception): + edge_component = PFAComponent("/home/asd", actuator_udm) + assertNotIsInstance(edge_component, PFAComponent) + + def test_PFAComponent_pass_with_valid_ModelPath(self): + with self.assertRaises(Exception): + edge_component = PFAComponent(ModelPath, actuator_udm) + assert isInstance(edge_component, PFAComponent) + + def test_PFAComponent_fails_without_valid_actionActuator(self): + #Fails if actuator_udm not of function type + with self.assertRaises(Exception): + edge_component = PFAComponent(ModelPath, "asd") + assertNotIsInstance(edge_component, PFAComponent) + + def test_PFAComponent_takes_valid_actionActuator(self): + edge_component = PFAComponent(ModelPath, actuator_udm) + assert isinstance(edge_component, PFAComponent) + +if __name__ == '__main__': + unittest.main() diff --git a/tests/unit/edge_intelligence/rule_edge_component_test.py b/tests/unit/edge_intelligence/rule_edge_component_test.py new file mode 100755 index 00000000..052d4f87 --- /dev/null +++ b/tests/unit/edge_intelligence/rule_edge_component_test.py @@ -0,0 +1,85 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +import unittest +from liota.edge_component.rule_edge_component import RuleEdgeComponent + +def actuator_udm(): + pass + +ModelRule = lambda rpm : 1 if (rpm>=rpm_limit) else 0 +exceed_limit = 1 + +class TestRuleEdgeComponent(unittest.TestCase): + + def test_RuleEdgeComponent_fail_without_valid_modelRule(self): + #Fails if no argument pass + with self.assertRaises(Exception): + edge_component = RuleEdgeComponent() + assertNotIsInstance(edge_component, RuleEdgeComponent) + + #Fails if not valid Model rule passed + with self.assertRaises(Exception): + edge_component = RuleEdgeComponent("asd", exceed_limit, actuator_udm) + assertNotIsInstance(edge_component, RuleEdgeComponent) + + #Fails if lambda function not passed as ModelRule + with self.assertRaises(Exception): + edge_component = RuleEdgeComponent(actuator_udm, exceed_limit, actuator_udm) + assertNotIsInstance(edge_component, RuleEdgeComponent) + + def test_RuleEdgeComponent_takes_valid_modelRule(self): + edge_component = RuleEdgeComponent(ModelRule, exceed_limit, actuator_udm) + assert isinstance(edge_component, RuleEdgeComponent) + + def test_RuleEdgeComponent_fail_with_invalidArg_exceedLimit(self): + #Fails if int not passed as exceed_limit + with self.assertRaises(Exception): + edge_component = RuleEdgeComponent(ModelRule, 2.0, actuator_udm) + assertNotIsInstance(edge_component, RuleEdgeComponent) + + def test_RuleEdgeComponent_takes_validArg_exceedLimit(self): + edge_component = RuleEdgeComponent(ModelRule, exceed_limit, actuator_udm) + assert isinstance(edge_component, RuleEdgeComponent) + + def test_RuleEdgeComponent_fails_without_valid_actionActuator(self): + #Fails if actuator_udm not of function type + with self.assertRaises(Exception): + edge_component = RuleEdgeComponent(ModelRule, exceed_limit, "asd") + assertNotIsInstance(edge_component, RuleEdgeComponent) + + def test_RuleEdgeComponent_takes_valid_actionActuator(self): + edge_component = RuleEdgeComponent(ModelRule, exceed_limit, actuator_udm) + assert isinstance(edge_component, RuleEdgeComponent) + +if __name__ == '__main__': + unittest.main() diff --git a/tests/unit/edge_intelligence/sklearn_component_test.py b/tests/unit/edge_intelligence/sklearn_component_test.py new file mode 100755 index 00000000..c92eca03 --- /dev/null +++ b/tests/unit/edge_intelligence/sklearn_component_test.py @@ -0,0 +1,64 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +import unittest +from liota.edge_component.sklearn_edge_component import SKLearnEdgeComponent + +def actuator_udm(): + pass + +ModelPath = "ModelPath" + +class TestSKLearnEdgeComponent(unittest.TestCase): + + def test_SKLearnEdgeComponent_fails_without_valid_ModelPath(self): + with self.assertRaises(Exception): + edge_component = SKLearnEdgeComponent("/home/asd", "asd") + assertNotIsInstance(edge_component, SKLearnEdgeComponent) + + def test_SKLearnEdgeComponent_pass_with_valid_ModelPath(self): + with self.assertRaises(Exception): + edge_component = SKLearnEdgeComponent(ModelPath, actuator_udm) + assert isInstance(edge_component, SKLearnEdgeComponent) + + def test_SKLearnEdgeComponent_fails_without_valid_actionActuator(self): + #Fails if actuator_udm not of function type + with self.assertRaises(Exception): + edge_component = SKLearnEdgeComponent(ModelPath, "asd") + assertNotIsInstance(edge_component, SKLearnEdgeComponent) + + def test_SKLearnEdgeComponent_takes_valid_actionActuator(self): + edge_component = SKLearnEdgeComponent(ModelPath, actuator_udm) + assert isinstance(edge_component, SKLearnEdgeComponent) + +if __name__ == '__main__': + unittest.main() diff --git a/tests/unit/edge_intelligence/tf_edge_component_test.py b/tests/unit/edge_intelligence/tf_edge_component_test.py new file mode 100644 index 00000000..3781cf77 --- /dev/null +++ b/tests/unit/edge_intelligence/tf_edge_component_test.py @@ -0,0 +1,64 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------# +# Copyright © 2015-2016 VMware, Inc. All Rights Reserved. # +# # +# Licensed under the BSD 2-Clause License (the “License”); you may not use # +# this file except in compliance with the License. # +# # +# The BSD 2-Clause License # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions are met:# +# # +# - Redistributions of source code must retain the above copyright notice, # +# this list of conditions and the following disclaimer. # +# # +# - Redistributions in binary form must reproduce the above copyright # +# notice, this list of conditions and the following disclaimer in the # +# documentation and/or other materials provided with the distribution. # +# # +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"# +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF # +# THE POSSIBILITY OF SUCH DAMAGE. # +# ----------------------------------------------------------------------------# + +import unittest +from liota.edge_component.tensorflow_edge_component import TensorFlowEdgeComponent + +def actuator_udm(): + pass + +ModelPath = "ModelPath" + +class TestTensorFlowEdgeComponent(unittest.TestCase): + + def test_TensorFlowEdgeComponent_fails_without_valid_ModelPath(self): + with self.assertRaises(Exception): + edge_component = TensorFlowEdgeComponent("/home/asd", actuator_udm) + assertNotIsInstance(edge_component, TensorFlowEdgeComponent) + + def test_TensorFlowEdgeComponent_pass_with_valid_ModelPath(self): + with self.assertRaises(Exception): + edge_component = TensorFlowEdgeComponent(ModelPath, actuator_udm) + assert isInstance(edge_component, TensorFlowEdgeComponent) + + def test_TensorFlowEdgeComponent_fails_without_valid_actionActuator(self): + #Fails if actuator_udm not of function type + with self.assertRaises(Exception): + edge_component = TensorFlowEdgeComponent(ModelPath, "asd") + assertNotIsInstance(edge_component, TensorFlowEdgeComponent) + + def test_TensorFlowEdgeComponent_takes_valid_actionActuator(self): + edge_component = TensorFlowEdgeComponent(ModelPath, actuator_udm) + assert isinstance(edge_component, TensorFlowEdgeComponent) + +if __name__ == '__main__': + unittest.main()