diff --git a/.idea/Larc2017Simulator.iml b/.idea/Larc2017Simulator.iml new file mode 100644 index 0000000..d0876a7 --- /dev/null +++ b/.idea/Larc2017Simulator.iml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/inspectionProfiles/profiles_settings.xml b/.idea/inspectionProfiles/profiles_settings.xml new file mode 100644 index 0000000..c23ecac --- /dev/null +++ b/.idea/inspectionProfiles/profiles_settings.xml @@ -0,0 +1,7 @@ + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..d870ac7 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..0dcac58 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..94a25f7 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/workspace.xml b/.idea/workspace.xml new file mode 100644 index 0000000..f207243 --- /dev/null +++ b/.idea/workspace.xml @@ -0,0 +1,984 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + error + sleep + bestId + points + + + $PROJECT_DIR$ + + + + + + + + + + + true + DEFINITION_ORDER + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + project + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1497545662871 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/interface.py b/interface.py index 7cb20ea..22881b4 100644 --- a/interface.py +++ b/interface.py @@ -106,7 +106,7 @@ def get_position_from_handle(self, handle): :param handle: :return: """ - pos = [[],[]] + pos = [[], []] _, pos[0] = vrep.simxGetObjectPosition(self.clientID, handle, - 1, vrep.simx_opmode_streaming) _, pos[1] = vrep.simxGetObjectOrientation(self.clientID, handle, - 1, vrep.simx_opmode_streaming) return pos @@ -121,7 +121,7 @@ def read_sensors(self): """ ret = {} for sensor, handle in self.proximity.items(): - _, detectionState, position, _, _ = vrep.simxReadProximitySensor(self.clientID, handle, vrep.simx_opmode_oneshot_wait) + _, detectionState, position, _, _ = vrep.simxReadProximitySensor(self.clientID, handle, vrep.simx_opmode_streaming) if not detectionState: position = (0, 0, 0) distance = sqrt(sum([coord**2 for coord in position])) diff --git a/larcscene.ttt b/larcscene.ttt index d3e5cc5..d27fc6a 100644 Binary files a/larcscene.ttt and b/larcscene.ttt differ diff --git a/navigator.py b/navigator.py new file mode 100644 index 0000000..3fdd5c6 --- /dev/null +++ b/navigator.py @@ -0,0 +1,47 @@ + +import cv2 + +class Navigator(): + + states = ["WHERETHEFUCKAMI",] + + def __init__(self, interface): + self.state = self.states[0] + self.interface = interface + self.find_glass = False + + def iterate(self, tag_name, tag_angle, tag_distance, sensors, tag_image): + print(self.state, tag_name) + if self.state == "WHERETHEFUCKAMI": + + # TODO: replace with a decent controller + if not (tag_name is None): + if tag_name == "Y.png": + + # TODO: we need to avoid abruptal direction changes on the wheels, as the + # escs have a required timeout + speed = 1 + if tag_angle is not None and tag_angle[0] > 4: + self.interface.set_right_speed(- speed) + self.interface.set_left_speed(speed) + elif tag_angle is not None and tag_angle[0] < -4: + self.interface.set_right_speed(speed) + self.interface.set_left_speed(-speed) + else: + self.interface.set_right_speed(speed) + self.interface.set_left_speed(speed) + + if sensors['fr'][0]: + #got to a wall? + #self.state = "GETHEFUCKINGCUP" + pass + print("distance:", tag_distance) + else: + print(tag_name, tag_name is None) + print("FUCK, GOT ", tag_name, tag_name is not None, type(tag_name)) + self.state = "GENERALIZEDCHAOS" + self.interface.set_left_speed(0) + self.interface.set_right_speed(0) + cv2.imshow("fail", tag_image) + if self.state == "GETTHEFUCKINGCUP": + print("should be trying to get the cup, now") \ No newline at end of file diff --git a/neural/1 b/neural/1 new file mode 100644 index 0000000..e69de29 diff --git a/neural/dataset/Y/346.jpg b/neural/dataset/Y/346.jpg deleted file mode 100644 index e7a2647..0000000 Binary files a/neural/dataset/Y/346.jpg and /dev/null differ diff --git a/neural/dataset/Y/442.jpg b/neural/dataset/Y/442.jpg deleted file mode 100644 index bc0e6be..0000000 Binary files a/neural/dataset/Y/442.jpg and /dev/null differ diff --git a/neural/dataset/Y/445.jpg b/neural/dataset/Y/445.jpg deleted file mode 100644 index 72ae80f..0000000 Binary files a/neural/dataset/Y/445.jpg and /dev/null differ diff --git a/neural/dataset/Y/446.jpg b/neural/dataset/Y/446.jpg deleted file mode 100644 index 0b2d6e6..0000000 Binary files a/neural/dataset/Y/446.jpg and /dev/null differ diff --git a/neural/dataset/Y/447.jpg b/neural/dataset/Y/447.jpg deleted file mode 100644 index d314542..0000000 Binary files a/neural/dataset/Y/447.jpg and /dev/null differ diff --git a/neural/dataset/Y/448.jpg b/neural/dataset/Y/448.jpg deleted file mode 100644 index 34d573b..0000000 Binary files a/neural/dataset/Y/448.jpg and /dev/null differ diff --git a/neural/model/checkpoint b/neural/model/checkpoint new file mode 100644 index 0000000..603c273 --- /dev/null +++ b/neural/model/checkpoint @@ -0,0 +1,5 @@ +model_checkpoint_path: "model.ckpt-10000" +all_model_checkpoint_paths: "model.ckpt-1" +all_model_checkpoint_paths: "model.ckpt-5000" +all_model_checkpoint_paths: "model.ckpt-5001" +all_model_checkpoint_paths: "model.ckpt-10000" diff --git a/neural/model/events.out.tfevents.1507119036.Will-Y50 b/neural/model/events.out.tfevents.1507119036.Will-Y50 new file mode 100644 index 0000000..dfb0359 Binary files /dev/null and b/neural/model/events.out.tfevents.1507119036.Will-Y50 differ diff --git a/neural/model/events.out.tfevents.1507119474.Will-Y50 b/neural/model/events.out.tfevents.1507119474.Will-Y50 new file mode 100644 index 0000000..bc2848f Binary files /dev/null and b/neural/model/events.out.tfevents.1507119474.Will-Y50 differ diff --git a/neural/model/graph.pbtxt b/neural/model/graph.pbtxt new file mode 100644 index 0000000..f259b51 --- /dev/null +++ b/neural/model/graph.pbtxt @@ -0,0 +1,9763 @@ +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: "input" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 40 + } + dim { + size: 40 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_UINT8 + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + dim { + size: 40 + } + dim { + size: 40 + } + } + } + } +} +node { + name: "output" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT64 + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + } + } + } +} +node { + name: "ToFloat" + op: "Cast" + input: "input" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 40 + } + dim { + size: 40 + } + } + } + } + } +} +node { + name: "InnerFlatten/assert_rank_at_least/rank" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "InnerFlatten/assert_rank_at_least/Shape" + op: "Shape" + input: "ToFloat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "InnerFlatten/assert_rank_at_least/assert_type/statically_determined_correct_type" + op: "NoOp" +} +node { + name: "InnerFlatten/assert_rank_at_least/static_checks_determined_all_ok" + op: "NoOp" +} +node { + name: "InnerFlatten/Shape" + op: "Shape" + input: "ToFloat" + input: "^InnerFlatten/assert_rank_at_least/static_checks_determined_all_ok" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "InnerFlatten/ones_like/tensor" + op: "Const" + input: "^InnerFlatten/assert_rank_at_least/static_checks_determined_all_ok" + 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: "InnerFlatten/ones_like/Shape" + op: "Const" + input: "^InnerFlatten/assert_rank_at_least/static_checks_determined_all_ok" + 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: "InnerFlatten/ones_like/Const" + op: "Const" + input: "^InnerFlatten/assert_rank_at_least/static_checks_determined_all_ok" + 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: "InnerFlatten/ones_like" + op: "Fill" + input: "InnerFlatten/ones_like/Shape" + input: "InnerFlatten/ones_like/Const" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "InnerFlatten/StridedSlice/begin" + op: "Const" + input: "^InnerFlatten/assert_rank_at_least/static_checks_determined_all_ok" + 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: "InnerFlatten/StridedSlice/end" + op: "Const" + input: "^InnerFlatten/assert_rank_at_least/static_checks_determined_all_ok" + 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: "InnerFlatten/StridedSlice" + op: "StridedSlice" + input: "InnerFlatten/Shape" + input: "InnerFlatten/StridedSlice/begin" + input: "InnerFlatten/StridedSlice/end" + input: "InnerFlatten/ones_like" + 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: 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: 0 + } + } +} +node { + name: "InnerFlatten/concat/values_1" + op: "Const" + input: "^InnerFlatten/assert_rank_at_least/static_checks_determined_all_ok" + 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: "InnerFlatten/concat/axis" + op: "Const" + input: "^InnerFlatten/assert_rank_at_least/static_checks_determined_all_ok" + 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: "InnerFlatten/concat" + op: "ConcatV2" + input: "InnerFlatten/StridedSlice" + input: "InnerFlatten/concat/values_1" + input: "InnerFlatten/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: 2 + } + } + } + } + } +} +node { + name: "InnerFlatten/Reshape" + op: "Reshape" + input: "ToFloat" + input: "InnerFlatten/concat" + 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: 1600 + } + } + } + } + } +} +node { + name: "dnn/input_from_feature_columns/input_from_feature_columns/concat/concat_dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "dnn/input_from_feature_columns/input_from_feature_columns/concat" + op: "Identity" + input: "InnerFlatten/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1600 + } + } + } + } + } +} +node { + name: "dnn/logits/weights/part_0/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/part_0" + } + } + } + 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: "@\006\000\000\004\000\000\000" + } + } + } +} +node { + name: "dnn/logits/weights/part_0/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/part_0" + } + } + } + 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.06116084009408951 + } + } + } +} +node { + name: "dnn/logits/weights/part_0/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/part_0" + } + } + } + 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.06116084009408951 + } + } + } +} +node { + name: "dnn/logits/weights/part_0/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "dnn/logits/weights/part_0/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1600 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 0 + } + } + attr { + key: "seed2" + value { + i: 0 + } + } +} +node { + name: "dnn/logits/weights/part_0/Initializer/random_uniform/sub" + op: "Sub" + input: "dnn/logits/weights/part_0/Initializer/random_uniform/max" + input: "dnn/logits/weights/part_0/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/logits/weights/part_0/Initializer/random_uniform/mul" + op: "Mul" + input: "dnn/logits/weights/part_0/Initializer/random_uniform/RandomUniform" + input: "dnn/logits/weights/part_0/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1600 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "dnn/logits/weights/part_0/Initializer/random_uniform" + op: "Add" + input: "dnn/logits/weights/part_0/Initializer/random_uniform/mul" + input: "dnn/logits/weights/part_0/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1600 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "dnn/logits/weights/part_0" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1600 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1600 + } + dim { + size: 4 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dnn/logits/weights/part_0/Assign" + op: "Assign" + input: "dnn/logits/weights/part_0" + input: "dnn/logits/weights/part_0/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1600 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "dnn/logits/weights/part_0/read" + op: "Identity" + input: "dnn/logits/weights/part_0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1600 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "dnn/logits/biases/part_0/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/biases/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 4 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "dnn/logits/biases/part_0" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/biases/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 4 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dnn/logits/biases/part_0/Assign" + op: "Assign" + input: "dnn/logits/biases/part_0" + input: "dnn/logits/biases/part_0/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/biases/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "dnn/logits/biases/part_0/read" + op: "Identity" + input: "dnn/logits/biases/part_0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/biases/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "dnn/logits/weights" + op: "Identity" + input: "dnn/logits/weights/part_0/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1600 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "dnn/logits/MatMul" + op: "MatMul" + input: "dnn/input_from_feature_columns/input_from_feature_columns/concat" + input: "dnn/logits/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "dnn/logits/biases" + op: "Identity" + input: "dnn/logits/biases/part_0/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "dnn/logits/BiasAdd" + op: "BiasAdd" + input: "dnn/logits/MatMul" + input: "dnn/logits/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "dnn/zero_fraction/zero" + 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: "dnn/zero_fraction/Equal" + op: "Equal" + input: "dnn/logits/BiasAdd" + input: "dnn/zero_fraction/zero" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "dnn/zero_fraction/Cast" + op: "Cast" + input: "dnn/zero_fraction/Equal" + 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: 4 + } + } + } + } + } +} +node { + name: "dnn/zero_fraction/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: "dnn/zero_fraction/Mean" + op: "Mean" + input: "dnn/zero_fraction/Cast" + input: "dnn/zero_fraction/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: "dnn/dnn/logits_fraction_of_zero_values/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: "dnn/dnn/logits_fraction_of_zero_values" + } + } + } +} +node { + name: "dnn/dnn/logits_fraction_of_zero_values" + op: "ScalarSummary" + input: "dnn/dnn/logits_fraction_of_zero_values/tags" + input: "dnn/zero_fraction/Mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/dnn/logits_activation/tag" + 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: "dnn/dnn/logits_activation" + } + } + } +} +node { + name: "dnn/dnn/logits_activation" + op: "HistogramSummary" + input: "dnn/dnn/logits_activation/tag" + input: "dnn/logits/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_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: "dnn/multi_class_head/predictions/classes" + op: "ArgMax" + input: "dnn/logits/BiasAdd" + input: "dnn/multi_class_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: -1 + } + } + } + } + } + attr { + key: "output_type" + value { + type: DT_INT64 + } + } +} +node { + name: "dnn/multi_class_head/predictions/probabilities" + op: "Softmax" + input: "dnn/logits/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "dnn/multi_class_head/softmax_cross_entropy_loss/Shape" + op: "Shape" + input: "output" + attr { + key: "T" + value { + type: DT_INT64 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "dnn/multi_class_head/softmax_cross_entropy_loss" + op: "SparseSoftmaxCrossEntropyWithLogits" + input: "dnn/logits/BiasAdd" + input: "output" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tlabels" + value { + type: DT_INT64 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "dnn/multi_class_head/softmax_cross_entropy_loss/loss/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: "dnn/multi_class_head/softmax_cross_entropy_loss/loss" + op: "Mean" + input: "dnn/multi_class_head/softmax_cross_entropy_loss" + input: "dnn/multi_class_head/softmax_cross_entropy_loss/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: "dnn/multi_class_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: "dnn/multi_class_head/ScalarSummary" + op: "ScalarSummary" + input: "dnn/multi_class_head/ScalarSummary/tags" + input: "dnn/multi_class_head/softmax_cross_entropy_loss/loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_head/Shape" + op: "Shape" + input: "dnn/logits/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "dnn/multi_class_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: "dnn/multi_class_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: "dnn/multi_class_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: "dnn/multi_class_head/strided_slice" + op: "StridedSlice" + input: "dnn/multi_class_head/Shape" + input: "dnn/multi_class_head/strided_slice/stack" + input: "dnn/multi_class_head/strided_slice/stack_1" + input: "dnn/multi_class_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: "dnn/multi_class_head/dnn/learning_rate/Initializer/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/dnn/learning_rate" + } + } + } + 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.05000000074505806 + } + } + } +} +node { + name: "dnn/multi_class_head/dnn/learning_rate" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/dnn/learning_rate" + } + } + } + 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: "dnn/multi_class_head/dnn/learning_rate/Assign" + op: "Assign" + input: "dnn/multi_class_head/dnn/learning_rate" + input: "dnn/multi_class_head/dnn/learning_rate/Initializer/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/dnn/learning_rate" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "dnn/multi_class_head/dnn/learning_rate/read" + op: "Identity" + input: "dnn/multi_class_head/dnn/learning_rate" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/dnn/learning_rate" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/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: "dnn/multi_class_head/train_op/dnn/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: "dnn/multi_class_head/train_op/dnn/gradients/Fill" + op: "Fill" + input: "dnn/multi_class_head/train_op/dnn/gradients/Shape" + input: "dnn/multi_class_head/train_op/dnn/gradients/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Reshape/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: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Reshape" + op: "Reshape" + input: "dnn/multi_class_head/train_op/dnn/gradients/Fill" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/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 + } + } + } + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Shape" + op: "Shape" + input: "dnn/multi_class_head/softmax_cross_entropy_loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Tile" + op: "Tile" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Reshape" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Shape_1" + op: "Shape" + input: "dnn/multi_class_head/softmax_cross_entropy_loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Shape_2" + 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: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/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: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Prod" + op: "Prod" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Shape_1" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/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: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/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: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Prod_1" + op: "Prod" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Shape_2" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/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: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/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: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Maximum" + op: "Maximum" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Prod_1" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Maximum/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/floordiv" + op: "FloorDiv" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Prod" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Maximum" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Cast" + op: "Cast" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/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: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/truediv" + op: "RealDiv" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Tile" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/Cast" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/zeros_like" + op: "ZerosLike" + input: "dnn/multi_class_head/softmax_cross_entropy_loss:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss_grad/PreventGradient" + op: "PreventGradient" + input: "dnn/multi_class_head/softmax_cross_entropy_loss:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "message" + value { + s: "Currently there is no way to take the second derivative of sparse_softmax_cross_entropy_with_logits due to the fused implementation\'s interaction with tf.gradients()" + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss_grad/ExpandDims/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss_grad/ExpandDims" + op: "ExpandDims" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss/loss_grad/truediv" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss_grad/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: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss_grad/mul" + op: "Mul" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss_grad/ExpandDims" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss_grad/PreventGradient" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss_grad/mul" + input: "^dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/BiasAdd_grad/BiasAddGrad" +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss_grad/mul" + input: "^dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/train_op/dnn/gradients/dnn/multi_class_head/softmax_cross_entropy_loss_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/BiasAdd_grad/BiasAddGrad" + input: "^dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/MatMul_grad/MatMul" + op: "MatMul" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/BiasAdd_grad/tuple/control_dependency" + input: "dnn/logits/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1600 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/MatMul_grad/MatMul_1" + op: "MatMul" + input: "dnn/input_from_feature_columns/input_from_feature_columns/concat" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1600 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: true + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/MatMul_grad/tuple/group_deps" + op: "NoOp" + input: "^dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/MatMul_grad/MatMul" + input: "^dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/MatMul_grad/MatMul_1" +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/MatMul_grad/tuple/control_dependency" + op: "Identity" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/MatMul_grad/MatMul" + input: "^dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/MatMul_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/MatMul_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1600 + } + } + } + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/MatMul_grad/tuple/control_dependency_1" + op: "Identity" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/MatMul_grad/MatMul_1" + input: "^dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/MatMul_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/MatMul_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1600 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "dnn/multi_class_head/dnn/dnn/logits/weights/part_0/Adagrad/Initializer/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1600 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1600 + } + dim { + size: 4 + } + } + float_val: 0.10000000149011612 + } + } + } +} +node { + name: "dnn/multi_class_head/dnn/dnn/logits/weights/part_0/Adagrad" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1600 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1600 + } + dim { + size: 4 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dnn/multi_class_head/dnn/dnn/logits/weights/part_0/Adagrad/Assign" + op: "Assign" + input: "dnn/multi_class_head/dnn/dnn/logits/weights/part_0/Adagrad" + input: "dnn/multi_class_head/dnn/dnn/logits/weights/part_0/Adagrad/Initializer/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1600 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "dnn/multi_class_head/dnn/dnn/logits/weights/part_0/Adagrad/read" + op: "Identity" + input: "dnn/multi_class_head/dnn/dnn/logits/weights/part_0/Adagrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1600 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "dnn/multi_class_head/dnn/dnn/logits/biases/part_0/Adagrad/Initializer/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/biases/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 4 + } + } + float_val: 0.10000000149011612 + } + } + } +} +node { + name: "dnn/multi_class_head/dnn/dnn/logits/biases/part_0/Adagrad" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/biases/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 4 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dnn/multi_class_head/dnn/dnn/logits/biases/part_0/Adagrad/Assign" + op: "Assign" + input: "dnn/multi_class_head/dnn/dnn/logits/biases/part_0/Adagrad" + input: "dnn/multi_class_head/dnn/dnn/logits/biases/part_0/Adagrad/Initializer/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/biases/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "dnn/multi_class_head/dnn/dnn/logits/biases/part_0/Adagrad/read" + op: "Identity" + input: "dnn/multi_class_head/dnn/dnn/logits/biases/part_0/Adagrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/biases/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/train/update_dnn/logits/weights/part_0/ApplyAdagrad" + op: "ApplyAdagrad" + input: "dnn/logits/weights/part_0" + input: "dnn/multi_class_head/dnn/dnn/logits/weights/part_0/Adagrad" + input: "dnn/multi_class_head/dnn/learning_rate/read" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/MatMul_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1600 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/train/update_dnn/logits/biases/part_0/ApplyAdagrad" + op: "ApplyAdagrad" + input: "dnn/logits/biases/part_0" + input: "dnn/multi_class_head/dnn/dnn/logits/biases/part_0/Adagrad" + input: "dnn/multi_class_head/dnn/learning_rate/read" + input: "dnn/multi_class_head/train_op/dnn/gradients/dnn/logits/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/biases/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "dnn/multi_class_head/train_op/dnn/train/update" + op: "NoOp" + input: "^dnn/multi_class_head/train_op/dnn/train/update_dnn/logits/weights/part_0/ApplyAdagrad" + input: "^dnn/multi_class_head/train_op/dnn/train/update_dnn/logits/biases/part_0/ApplyAdagrad" +} +node { + name: "dnn/multi_class_head/train_op/dnn/train/value" + op: "Const" + input: "^dnn/multi_class_head/train_op/dnn/train/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: "dnn/multi_class_head/train_op/dnn/train" + op: "AssignAdd" + input: "global_step" + input: "dnn/multi_class_head/train_op/dnn/train/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: "dnn/multi_class_head/train_op/dnn/control_dependency" + op: "Identity" + input: "dnn/multi_class_head/softmax_cross_entropy_loss/loss" + input: "^dnn/multi_class_head/train_op/dnn/train" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/softmax_cross_entropy_loss/loss" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_head/metrics/mean/total/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/mean/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "dnn/multi_class_head/metrics/mean/total" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/mean/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dnn/multi_class_head/metrics/mean/total/Assign" + op: "Assign" + input: "dnn/multi_class_head/metrics/mean/total" + input: "dnn/multi_class_head/metrics/mean/total/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_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: "dnn/multi_class_head/metrics/mean/total/read" + op: "Identity" + input: "dnn/multi_class_head/metrics/mean/total" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/mean/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_head/metrics/mean/count/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/mean/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "dnn/multi_class_head/metrics/mean/count" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/mean/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dnn/multi_class_head/metrics/mean/count/Assign" + op: "Assign" + input: "dnn/multi_class_head/metrics/mean/count" + input: "dnn/multi_class_head/metrics/mean/count/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_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: "dnn/multi_class_head/metrics/mean/count/read" + op: "Identity" + input: "dnn/multi_class_head/metrics/mean/count" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/mean/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_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: "dnn/multi_class_head/metrics/mean/ToFloat_1" + op: "Cast" + input: "dnn/multi_class_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: "dnn/multi_class_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: "dnn/multi_class_head/metrics/mean/Sum" + op: "Sum" + input: "dnn/multi_class_head/softmax_cross_entropy_loss/loss" + input: "dnn/multi_class_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: "dnn/multi_class_head/metrics/mean/AssignAdd" + op: "AssignAdd" + input: "dnn/multi_class_head/metrics/mean/total" + input: "dnn/multi_class_head/metrics/mean/Sum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/mean/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "dnn/multi_class_head/metrics/mean/AssignAdd_1" + op: "AssignAdd" + input: "dnn/multi_class_head/metrics/mean/count" + input: "dnn/multi_class_head/metrics/mean/ToFloat_1" + input: "^dnn/multi_class_head/softmax_cross_entropy_loss/loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/mean/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "dnn/multi_class_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: "dnn/multi_class_head/metrics/mean/Greater" + op: "Greater" + input: "dnn/multi_class_head/metrics/mean/count/read" + input: "dnn/multi_class_head/metrics/mean/Greater/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_head/metrics/mean/truediv" + op: "RealDiv" + input: "dnn/multi_class_head/metrics/mean/total/read" + input: "dnn/multi_class_head/metrics/mean/count/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_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: "dnn/multi_class_head/metrics/mean/value" + op: "Select" + input: "dnn/multi_class_head/metrics/mean/Greater" + input: "dnn/multi_class_head/metrics/mean/truediv" + input: "dnn/multi_class_head/metrics/mean/value/e" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_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: "dnn/multi_class_head/metrics/mean/Greater_1" + op: "Greater" + input: "dnn/multi_class_head/metrics/mean/AssignAdd_1" + input: "dnn/multi_class_head/metrics/mean/Greater_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_head/metrics/mean/truediv_1" + op: "RealDiv" + input: "dnn/multi_class_head/metrics/mean/AssignAdd" + input: "dnn/multi_class_head/metrics/mean/AssignAdd_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_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: "dnn/multi_class_head/metrics/mean/update_op" + op: "Select" + input: "dnn/multi_class_head/metrics/mean/Greater_1" + input: "dnn/multi_class_head/metrics/mean/truediv_1" + input: "dnn/multi_class_head/metrics/mean/update_op/e" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_head/metrics/Equal" + op: "Equal" + input: "dnn/multi_class_head/predictions/classes" + input: "output" + attr { + key: "T" + value { + type: DT_INT64 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "dnn/multi_class_head/metrics/ToFloat" + op: "Cast" + input: "dnn/multi_class_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: -1 + } + } + } + } + } +} +node { + name: "dnn/multi_class_head/metrics/accuracy/total/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/accuracy/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "dnn/multi_class_head/metrics/accuracy/total" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/accuracy/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dnn/multi_class_head/metrics/accuracy/total/Assign" + op: "Assign" + input: "dnn/multi_class_head/metrics/accuracy/total" + input: "dnn/multi_class_head/metrics/accuracy/total/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_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: "dnn/multi_class_head/metrics/accuracy/total/read" + op: "Identity" + input: "dnn/multi_class_head/metrics/accuracy/total" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/accuracy/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_head/metrics/accuracy/count/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/accuracy/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "dnn/multi_class_head/metrics/accuracy/count" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/accuracy/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dnn/multi_class_head/metrics/accuracy/count/Assign" + op: "Assign" + input: "dnn/multi_class_head/metrics/accuracy/count" + input: "dnn/multi_class_head/metrics/accuracy/count/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_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: "dnn/multi_class_head/metrics/accuracy/count/read" + op: "Identity" + input: "dnn/multi_class_head/metrics/accuracy/count" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/accuracy/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_head/metrics/accuracy/Size" + op: "Size" + input: "dnn/multi_class_head/metrics/ToFloat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "dnn/multi_class_head/metrics/accuracy/ToFloat_1" + op: "Cast" + input: "dnn/multi_class_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: "dnn/multi_class_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: "dnn/multi_class_head/metrics/accuracy/Sum" + op: "Sum" + input: "dnn/multi_class_head/metrics/ToFloat" + input: "dnn/multi_class_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: "dnn/multi_class_head/metrics/accuracy/AssignAdd" + op: "AssignAdd" + input: "dnn/multi_class_head/metrics/accuracy/total" + input: "dnn/multi_class_head/metrics/accuracy/Sum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/accuracy/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "dnn/multi_class_head/metrics/accuracy/AssignAdd_1" + op: "AssignAdd" + input: "dnn/multi_class_head/metrics/accuracy/count" + input: "dnn/multi_class_head/metrics/accuracy/ToFloat_1" + input: "^dnn/multi_class_head/metrics/ToFloat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/accuracy/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } +} +node { + name: "dnn/multi_class_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: "dnn/multi_class_head/metrics/accuracy/Greater" + op: "Greater" + input: "dnn/multi_class_head/metrics/accuracy/count/read" + input: "dnn/multi_class_head/metrics/accuracy/Greater/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_head/metrics/accuracy/truediv" + op: "RealDiv" + input: "dnn/multi_class_head/metrics/accuracy/total/read" + input: "dnn/multi_class_head/metrics/accuracy/count/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_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: "dnn/multi_class_head/metrics/accuracy/value" + op: "Select" + input: "dnn/multi_class_head/metrics/accuracy/Greater" + input: "dnn/multi_class_head/metrics/accuracy/truediv" + input: "dnn/multi_class_head/metrics/accuracy/value/e" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_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: "dnn/multi_class_head/metrics/accuracy/Greater_1" + op: "Greater" + input: "dnn/multi_class_head/metrics/accuracy/AssignAdd_1" + input: "dnn/multi_class_head/metrics/accuracy/Greater_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_head/metrics/accuracy/truediv_1" + op: "RealDiv" + input: "dnn/multi_class_head/metrics/accuracy/AssignAdd" + input: "dnn/multi_class_head/metrics/accuracy/AssignAdd_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_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: "dnn/multi_class_head/metrics/accuracy/update_op" + op: "Select" + input: "dnn/multi_class_head/metrics/accuracy/Greater_1" + input: "dnn/multi_class_head/metrics/accuracy/truediv_1" + input: "dnn/multi_class_head/metrics/accuracy/update_op/e" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "dnn/multi_class_head/_classification_output_alternatives/Shape" + op: "Shape" + input: "dnn/multi_class_head/predictions/probabilities" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "dnn/multi_class_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: "dnn/multi_class_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: "dnn/multi_class_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: "dnn/multi_class_head/_classification_output_alternatives/strided_slice" + op: "StridedSlice" + input: "dnn/multi_class_head/_classification_output_alternatives/Shape" + input: "dnn/multi_class_head/_classification_output_alternatives/strided_slice/stack" + input: "dnn/multi_class_head/_classification_output_alternatives/strided_slice/stack_1" + input: "dnn/multi_class_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: "dnn/multi_class_head/_classification_output_alternatives/Shape_1" + op: "Shape" + input: "dnn/multi_class_head/predictions/probabilities" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "dnn/multi_class_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: "dnn/multi_class_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: "dnn/multi_class_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: "dnn/multi_class_head/_classification_output_alternatives/strided_slice_1" + op: "StridedSlice" + input: "dnn/multi_class_head/_classification_output_alternatives/Shape_1" + input: "dnn/multi_class_head/_classification_output_alternatives/strided_slice_1/stack" + input: "dnn/multi_class_head/_classification_output_alternatives/strided_slice_1/stack_1" + input: "dnn/multi_class_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: "dnn/multi_class_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: "dnn/multi_class_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: "dnn/multi_class_head/_classification_output_alternatives/range" + op: "Range" + input: "dnn/multi_class_head/_classification_output_alternatives/range/start" + input: "dnn/multi_class_head/_classification_output_alternatives/strided_slice_1" + input: "dnn/multi_class_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: "dnn/multi_class_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: "dnn/multi_class_head/_classification_output_alternatives/ExpandDims" + op: "ExpandDims" + input: "dnn/multi_class_head/_classification_output_alternatives/range" + input: "dnn/multi_class_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: "dnn/multi_class_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: "dnn/multi_class_head/_classification_output_alternatives/Tile/multiples" + op: "Pack" + input: "dnn/multi_class_head/_classification_output_alternatives/strided_slice" + input: "dnn/multi_class_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: "dnn/multi_class_head/_classification_output_alternatives/Tile" + op: "Tile" + input: "dnn/multi_class_head/_classification_output_alternatives/ExpandDims" + input: "dnn/multi_class_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: "dnn/multi_class_head/_classification_output_alternatives/classes_tensor" + op: "AsString" + input: "dnn/multi_class_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: "^dnn/logits/weights/part_0/Assign" + input: "^dnn/logits/biases/part_0/Assign" + input: "^dnn/multi_class_head/dnn/learning_rate/Assign" + input: "^dnn/multi_class_head/dnn/dnn/logits/weights/part_0/Adagrad/Assign" + input: "^dnn/multi_class_head/dnn/dnn/logits/biases/part_0/Adagrad/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: "dnn/logits/weights/part_0" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/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: "dnn/logits/biases/part_0" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/biases/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: "dnn/multi_class_head/dnn/learning_rate" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/dnn/learning_rate" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_4" + op: "IsVariableInitialized" + input: "dnn/multi_class_head/dnn/dnn/logits/weights/part_0/Adagrad" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/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: "dnn/multi_class_head/dnn/dnn/logits/biases/part_0/Adagrad" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/biases/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: "dnn/multi_class_head/metrics/mean/total" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/mean/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_7" + op: "IsVariableInitialized" + input: "dnn/multi_class_head/metrics/mean/count" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/mean/count" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_8" + op: "IsVariableInitialized" + input: "dnn/multi_class_head/metrics/accuracy/total" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/accuracy/total" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_9" + op: "IsVariableInitialized" + input: "dnn/multi_class_head/metrics/accuracy/count" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/metrics/accuracy/count" + } + } + } + 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" + device: "/device:CPU:0" + attr { + key: "N" + value { + i: 10 + } + } + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 10 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "report_uninitialized_variables/LogicalNot" + op: "LogicalNot" + input: "report_uninitialized_variables/stack" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 10 + } + } + } + } + } +} +node { + name: "report_uninitialized_variables/Const" + op: "Const" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 10 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 10 + } + } + string_val: "global_step" + string_val: "dnn/logits/weights/part_0" + string_val: "dnn/logits/biases/part_0" + string_val: "dnn/multi_class_head/dnn/learning_rate" + string_val: "dnn/multi_class_head/dnn/dnn/logits/weights/part_0/Adagrad" + string_val: "dnn/multi_class_head/dnn/dnn/logits/biases/part_0/Adagrad" + string_val: "dnn/multi_class_head/metrics/mean/total" + string_val: "dnn/multi_class_head/metrics/mean/count" + string_val: "dnn/multi_class_head/metrics/accuracy/total" + string_val: "dnn/multi_class_head/metrics/accuracy/count" + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/Shape" + op: "Const" + device: "/device:CPU:0" + 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: 10 + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/strided_slice/stack" + op: "Const" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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: 10 + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/strided_slice_1/stack" + op: "Const" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 10 + } + } + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/Reshape_1/shape" + op: "Const" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 10 + } + } + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/Where" + op: "Where" + input: "report_uninitialized_variables/boolean_mask/Reshape_1" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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: "dnn/logits/weights/part_0" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/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: "dnn/logits/biases/part_0" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/biases/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: "dnn/multi_class_head/dnn/learning_rate" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/dnn/learning_rate" + } + } + } + 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: "dnn/multi_class_head/dnn/dnn/logits/weights/part_0/Adagrad" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/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: "dnn/multi_class_head/dnn/dnn/logits/biases/part_0/Adagrad" + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/biases/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" + device: "/device:CPU:0" + attr { + key: "N" + value { + i: 6 + } + } + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 6 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "report_uninitialized_variables_1/LogicalNot" + op: "LogicalNot" + input: "report_uninitialized_variables_1/stack" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 6 + } + } + } + } + } +} +node { + name: "report_uninitialized_variables_1/Const" + op: "Const" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 6 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 6 + } + } + string_val: "global_step" + string_val: "dnn/logits/weights/part_0" + string_val: "dnn/logits/biases/part_0" + string_val: "dnn/multi_class_head/dnn/learning_rate" + string_val: "dnn/multi_class_head/dnn/dnn/logits/weights/part_0/Adagrad" + string_val: "dnn/multi_class_head/dnn/dnn/logits/biases/part_0/Adagrad" + } + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/Shape" + op: "Const" + device: "/device:CPU:0" + 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: 6 + } + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/strided_slice/stack" + op: "Const" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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: 6 + } + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/strided_slice_1/stack" + op: "Const" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 6 + } + } + } + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/Reshape_1/shape" + op: "Const" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 6 + } + } + } + } + } +} +node { + name: "report_uninitialized_variables_1/boolean_mask/Where" + op: "Where" + input: "report_uninitialized_variables_1/boolean_mask/Reshape_1" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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" + device: "/device:CPU:0" + 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: "^dnn/multi_class_head/metrics/mean/total/Assign" + input: "^dnn/multi_class_head/metrics/mean/count/Assign" + input: "^dnn/multi_class_head/metrics/accuracy/total/Assign" + input: "^dnn/multi_class_head/metrics/accuracy/count/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: "dnn/dnn/logits_fraction_of_zero_values" + input: "dnn/dnn/logits_activation" + input: "dnn/multi_class_head/ScalarSummary" + attr { + key: "N" + value { + i: 3 + } + } + 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_1242f3ad6694421984b99428ee01efdb/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: 6 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 6 + } + } + string_val: "dnn/logits/biases" + string_val: "dnn/logits/biases/dnn/logits/biases/part_0/Adagrad" + string_val: "dnn/logits/weights" + string_val: "dnn/logits/weights/nn/logits/weights/part_0/Adagrad" + string_val: "dnn/multi_class_head/dnn/learning_rate" + string_val: "global_step" + } + } + } +} +node { + name: "save/SaveV2/shape_and_slices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 6 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 6 + } + } + string_val: "4 0,4" + string_val: "4 0,4" + string_val: "1600 4 0,1600:0,4" + string_val: "1600 4 0,1600:0,4" + string_val: "" + string_val: "" + } + } + } +} +node { + name: "save/SaveV2" + op: "SaveV2" + input: "save/ShardedFilename" + input: "save/SaveV2/tensor_names" + input: "save/SaveV2/shape_and_slices" + input: "dnn/logits/biases/part_0/read" + input: "dnn/multi_class_head/dnn/dnn/logits/biases/part_0/Adagrad/read" + input: "dnn/logits/weights/part_0/read" + input: "dnn/multi_class_head/dnn/dnn/logits/weights/part_0/Adagrad/read" + input: "dnn/multi_class_head/dnn/learning_rate" + input: "global_step" + attr { + key: "dtypes" + value { + list { + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_INT64 + } + } + } +} +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: "dnn/logits/biases" + } + } + } +} +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: "4 0,4" + } + } + } +} +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_FLOAT + } + } + } +} +node { + name: "save/Assign" + op: "Assign" + input: "dnn/logits/biases/part_0" + input: "save/RestoreV2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/biases/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + 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: "dnn/logits/biases/dnn/logits/biases/part_0/Adagrad" + } + } + } +} +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: "4 0,4" + } + } + } +} +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: "dnn/multi_class_head/dnn/dnn/logits/biases/part_0/Adagrad" + input: "save/RestoreV2_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/biases/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + 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: "dnn/logits/weights" + } + } + } +} +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: "1600 4 0,1600:0,4" + } + } + } +} +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: "dnn/logits/weights/part_0" + input: "save/RestoreV2_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1600 + } + dim { + size: 4 + } + } + } + } + } + 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: "dnn/logits/weights/nn/logits/weights/part_0/Adagrad" + } + } + } +} +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: "1600 4 0,1600:0,4" + } + } + } +} +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: "dnn/multi_class_head/dnn/dnn/logits/weights/part_0/Adagrad" + input: "save/RestoreV2_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/logits/weights/part_0" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1600 + } + dim { + size: 4 + } + } + } + } + } + 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: "dnn/multi_class_head/dnn/learning_rate" + } + } + } +} +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: "" + } + } + } +} +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: "dnn/multi_class_head/dnn/learning_rate" + input: "save/RestoreV2_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dnn/multi_class_head/dnn/learning_rate" + } + } + } + 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_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: "global_step" + } + } + } +} +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: "" + } + } + } +} +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_INT64 + } + } + } +} +node { + name: "save/Assign_5" + op: "Assign" + input: "global_step" + input: "save/RestoreV2_5" + 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/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" +} +node { + name: "save/restore_all" + op: "NoOp" + input: "^save/restore_shard" +} +versions { + producer: 24 +} diff --git a/neural/model/model.ckpt-1.data-00000-of-00001 b/neural/model/model.ckpt-1.data-00000-of-00001 new file mode 100644 index 0000000..e013dd0 Binary files /dev/null and b/neural/model/model.ckpt-1.data-00000-of-00001 differ diff --git a/neural/model/model.ckpt-1.index b/neural/model/model.ckpt-1.index new file mode 100644 index 0000000..683b5e1 Binary files /dev/null and b/neural/model/model.ckpt-1.index differ diff --git a/neural/model/model.ckpt-1.meta b/neural/model/model.ckpt-1.meta new file mode 100644 index 0000000..ba39d13 Binary files /dev/null and b/neural/model/model.ckpt-1.meta differ diff --git a/neural/model/model.ckpt-10000.data-00000-of-00001 b/neural/model/model.ckpt-10000.data-00000-of-00001 new file mode 100644 index 0000000..ddabdb6 Binary files /dev/null and b/neural/model/model.ckpt-10000.data-00000-of-00001 differ diff --git a/neural/model/model.ckpt-10000.index b/neural/model/model.ckpt-10000.index new file mode 100644 index 0000000..67a66df Binary files /dev/null and b/neural/model/model.ckpt-10000.index differ diff --git a/neural/model/model.ckpt-10000.meta b/neural/model/model.ckpt-10000.meta new file mode 100644 index 0000000..12595f8 Binary files /dev/null and b/neural/model/model.ckpt-10000.meta differ diff --git a/neural/model/model.ckpt-5000.data-00000-of-00001 b/neural/model/model.ckpt-5000.data-00000-of-00001 new file mode 100644 index 0000000..800d828 Binary files /dev/null and b/neural/model/model.ckpt-5000.data-00000-of-00001 differ diff --git a/neural/model/model.ckpt-5000.index b/neural/model/model.ckpt-5000.index new file mode 100644 index 0000000..5ed7083 Binary files /dev/null and b/neural/model/model.ckpt-5000.index differ diff --git a/neural/model/model.ckpt-5000.meta b/neural/model/model.ckpt-5000.meta new file mode 100644 index 0000000..5a44b70 Binary files /dev/null and b/neural/model/model.ckpt-5000.meta differ diff --git a/neural/model/model.ckpt-5001.data-00000-of-00001 b/neural/model/model.ckpt-5001.data-00000-of-00001 new file mode 100644 index 0000000..427befd Binary files /dev/null and b/neural/model/model.ckpt-5001.data-00000-of-00001 differ diff --git a/neural/model/model.ckpt-5001.index b/neural/model/model.ckpt-5001.index new file mode 100644 index 0000000..24659cd Binary files /dev/null and b/neural/model/model.ckpt-5001.index differ diff --git a/neural/model/model.ckpt-5001.meta b/neural/model/model.ckpt-5001.meta new file mode 100644 index 0000000..c8fe134 Binary files /dev/null and b/neural/model/model.ckpt-5001.meta differ diff --git a/neural/run_tf.py b/neural/run_tf.py index e51cc2a..44ccdb9 100644 --- a/neural/run_tf.py +++ b/neural/run_tf.py @@ -23,16 +23,17 @@ # Enable logging tf.logging.set_verbosity(tf.logging.INFO) # Create our classifier - feature_columns = [tf.contrib.layers.real_valued_column("", dimension=1024)] - classifier = tf.contrib.learn.DNNClassifier(feature_columns=feature_columns, hidden_units=[400, 400, 400, 400, 400, 400], n_classes=4, model_dir="model") + feature_columns = [tf.contrib.layers.real_valued_column("", dimension=1600)] + classifier = tf.contrib.learn.DNNClassifier(feature_columns=feature_columns, hidden_units=[], n_classes=4, model_dir="model") if args.train: print('Training...') - classifier.fit(X_train, y_train, steps=2000) + classifier.fit(X_train, y_train, steps=5000) print('Done !') # Evaluate test_count = 0 error_count = 0 + print(X_test.shape) for i in zip(classifier.predict_proba(X_test), classifier.predict_classes(X_test), classifier.predict(X_test)): print("model.predict_proba", "--", i[0], "model.predict", "--", i[2], "predict_clases", "--", i[1]) diff --git a/opencvpos.py b/opencvpos.py index 4f4b80c..c406279 100644 --- a/opencvpos.py +++ b/opencvpos.py @@ -3,7 +3,7 @@ import numpy as np import cv2 - +import tensorflow as tf class OpencvPos(): """ Black magic of infinity opencv skils and food with lactose @@ -16,6 +16,9 @@ def __init__(self): # matrix vector self.matrix_size = 40 self.mats = [self.create_mat_from_tag(tag, self.matrix_size) for tag in self.tags] + # camera fov + self.camera_fov = 60 # degrees + self.errors = [[100,0] for i in self.tags] self.goods = [0 for i in self.tags] @@ -25,6 +28,12 @@ def __init__(self): print('tags', self.tags) print('mats', self.mats) + + + self.session = tf.Session() + + + def create_mat_from_tag(self, img, size): # Create a matrix to compare with our candidate mat = cv2.cvtColor(img.copy(), cv2.COLOR_RGB2GRAY) @@ -49,6 +58,28 @@ def calc_img_eq_perc(self, ori, img): perc_total += rows_perc[0][i]*rows_perc[1][i]*(1-np.abs(np.sum(ori[i] - img[i]))/np.sum(ori[i])) return perc_total + def calc_img_eq_perc_neural(self, warp): + + # Run the initializer + #print("warp:", warp.shape) + #print(warp) + + with tf.device('/gpu:0'): + # Enable logging + tf.logging.set_verbosity(tf.logging.INFO) + # Create our classifier + feature_columns = [tf.contrib.layers.real_valued_column("", dimension=1600)] + classifier = tf.contrib.learn.DNNClassifier(feature_columns=feature_columns, + hidden_units=[], n_classes=4, + model_dir="neural/model") + tag_classes = ['AR', 'L', 'Y', None] + tag_index = classifier.predict_classes(warp.reshape(1, 40, 40), as_iterable=False)[0] + tag_index_prob = classifier.predict_proba(warp.reshape(1, 40, 40), as_iterable=False)[0] + print("prediction:", tag_classes[tag_index]) + print("probability:", tag_index_prob) + return tag_index + + def get_position_from_image(self, img): # Get the grayscale image and find some edges gray = img.copy() @@ -56,7 +87,8 @@ def get_position_from_image(self, img): # Keep only the most largest edges _, cnts, _ = cv2.findContours(edged.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) - cnts = sorted(cnts, key = cv2.contourArea, reverse = True) + cnts = [cv2.approxPolyDP(cnt, 3, True) for cnt in cnts] + cnts = sorted(cnts, key = cv2.contourArea, reverse=True) tagCntVec = [] # loop over our contours @@ -82,6 +114,7 @@ def get_position_from_image(self, img): # We have our candidates to be the best tag detection # time to choose a winner + found_tags = [] for tagCnt in tagCntVec: # resize pts = tagCnt.reshape(4, 2) @@ -91,6 +124,12 @@ def get_position_from_image(self, img): # the top-left point has the smallest sum whereas the # bottom-right has the largest sum + + # [0] -------[1] + # | | + # | | + # [3]--------[2] + s = pts.sum(axis = 1) rect[0] = pts[np.argmin(s)] rect[2] = pts[np.argmax(s)] @@ -175,36 +214,45 @@ def get_position_from_image(self, img): euler_angles = euler_angles.squeeze() # Remove some noise - warp = cv2.resize(warp,(40, 40)) + warp = cv2.resize(warp, (40, 40)) _, warp = cv2.threshold(warp, 127, 255, cv2.THRESH_BINARY) ## We can now compare - perc = [0 for i in self.tags] - lperc = 0 - ident = -1 - for i , _ in enumerate(self.tags): - p = self.calc_img_eq_perc(self.mats[i], warp) - if p == float('nan') or p == 0: - continue - perc[i] = p*100.0 - if (self.errors[i][0] > perc[i]): - self.errors[i][0] = perc[i] - if (self.errors[i][1] < perc[i]): - self.errors[i][1] = perc[i] - if perc[i] > lperc: - lperc = perc[i] - ident = i - #print(lperc, self.tags_name[ident]) - - if ident != -1: - self.goods[ident] += 1 - else: - self.goods[-1] += 1 - - if bestPerc < lperc: - bestPerc = lperc - bestId = ident - bestTagCnt = tagCnt - bestWarp = warp + #perc = [0 for i in self.tags] + #lperc = 0 + #ident = -1 + + + #for i , _ in enumerate(self.tags): + # p = self.calc_img_eq_perc(self.mats[i], warp) + # self.calc_img_eq_perc_neural(warp) + # if p == float('nan') or p == 0: + ## continue + # perc[i] = p*100.0 + # if (self.errors[i][0] > perc[i]): + # self.errors[i][0] = perc[i] + # if (self.errors[i][1] < perc[i]): + # self.errors[i][1] = perc[i] + # if perc[i] > lperc: + # lperc = perc[i] + # ident = i + # #print(lperc, self.tags_name[ident]) + + bestId = self.calc_img_eq_perc_neural(warp) + print(bestId) + bestTagCnt = tagCnt + + # if ident != -1: + # self.goods[ident] += 1 + # else: + # self.goods[-1] += 1 + # + # if bestPerc < lperc: + # bestPerc = lperc + # bestId = ident + #bestTagCnt = tagCnt + bestWarp = warp + if bestId != 3: + found_tags.append((bestId, bestTagCnt, bestWarp)) #Debug code # print percentage between mismatches and nondetect tags @@ -215,4 +263,19 @@ def get_position_from_image(self, img): print(bestPerc, self.tags_name[bestId]) ''' - return (bestPerc, self.tags_name[bestId], self.mats[bestId], bestWarp, bestTagCnt) + print("tags: ", len(found_tags)) + tag_name = self.tags_name[bestId-2] + image_size = img.shape + image_center = np.divide(image_size, 2) + points = bestTagCnt + #print(points) + tag_center = np.average(points, axis=0) + tag_angle = (tag_center - image_center)*self.camera_fov/image_size + + tag_shape = (np.max(points, axis=0) - np.min(points, axis=0))[0] + + tag_angular_size = np.radians(tag_shape*self.camera_fov/image_size/2) + + tag_guesstimated_distance = 10/np.tan(tag_angular_size) # using qrcode size / 2 + + return bestPerc, tag_name, self.mats[bestId-2], bestWarp, bestTagCnt, tag_angle[0], tag_guesstimated_distance diff --git a/robot.py b/robot.py index 30a0cfb..e8c0b7e 100644 --- a/robot.py +++ b/robot.py @@ -2,28 +2,44 @@ from interface import RobotInterface from input.keylistener import KeyListener from opencvpos import OpencvPos +from navigator import Navigator +import sys + +def paint_tag(img, tag_image, tag_detec): + img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB) + cv2.polylines(img, [points], True, (0, 255, 255)) + tag_image = cv2.cvtColor(tag_image, cv2.COLOR_GRAY2RGB) + tag_detec = cv2.cvtColor(tag_detec, cv2.COLOR_GRAY2RGB) + img[0:tag_image.shape[1], img.shape[0] - tag_image.shape[0]:img.shape[0]] = tag_image + img[tag_image.shape[1]:tag_image.shape[1] + tag_detec.shape[1], + img.shape[0] - tag_image.shape[0]:img.shape[0]] = tag_detec + return img interface = RobotInterface() opencvpos = OpencvPos() interface.gripper.move((0, 0, 0.02), False) keys = KeyListener() +navigator = Navigator(interface) +manual_mode = False while True: img = interface.get_image_from_camera() - print(interface.read_sensors()) - + sensors = interface.read_sensors() + tag_angle = None + tag_distance = None + tag_name = None + tag_image = None try: - perc, tag_name, tag_image, tag_detec, points = opencvpos.get_position_from_image(img) - img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB) - cv2.polylines(img,[points], True, (0,255,255)) - tag_image = cv2.cvtColor(tag_image, cv2.COLOR_GRAY2RGB) - tag_detec = cv2.cvtColor(tag_detec, cv2.COLOR_GRAY2RGB) - img[0:tag_image.shape[1], img.shape[0]-tag_image.shape[0]:img.shape[0]] = tag_image - img[tag_image.shape[1]:tag_image.shape[1] + tag_detec.shape[1], img.shape[0]-tag_image.shape[0]:img.shape[0]] = tag_detec - except: - print('Error in opencvpos!') + perc, tag_name, tag_image, tag_detec, points, tag_angle, tag_distance = opencvpos.get_position_from_image(img) + img = paint_tag(img, tag_image, tag_detec) + print(tag_angle, tag_distance) + + except Exception as e: + import traceback + print('Error in opencvpos!', e) + traceback.print_exc(file=sys.stdout) pass cv2.imshow("target", img) @@ -35,22 +51,26 @@ if ch == 27: break - if keys['w']: - left_speed += speed - right_speed += speed - if keys['s']: - left_speed -= speed - right_speed -= speed - if keys['a']: - left_speed -= speed - right_speed += speed - if keys['d']: - left_speed += speed - right_speed -= speed - interface.set_left_speed(left_speed) - interface.set_right_speed(right_speed) - - interface.gripper.move((0, 0, -0.001), False) + + if manual_mode: + if keys['w']: + left_speed += speed + right_speed += speed + if keys['s']: + left_speed -= speed + right_speed -= speed + if keys['a']: + left_speed -= speed + right_speed += speed + if keys['d']: + left_speed += speed + right_speed -= speed + interface.set_left_speed(left_speed) + interface.set_right_speed(right_speed) + + interface.gripper.move((0, 0, -0.001), False) + else: + navigator.iterate(tag_name, tag_angle, tag_distance, sensors, tag_image) interface.stop() cv2.destroyAllWindows()