diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/.idea/SfMLearner-master_for_TensorFlow.iml b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/.idea/SfMLearner-master_for_TensorFlow.iml new file mode 100644 index 0000000000000000000000000000000000000000..0dac5250540b9c161ded3dfb8786bd44c5738f8a --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/.idea/SfMLearner-master_for_TensorFlow.iml @@ -0,0 +1,12 @@ + + + + + + + + + + \ No newline at end of file diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/.idea/inspectionProfiles/profiles_settings.xml b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/.idea/inspectionProfiles/profiles_settings.xml new file mode 100644 index 0000000000000000000000000000000000000000..105ce2da2d6447d11dfe32bfb846c3d5b199fc99 --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/.idea/inspectionProfiles/profiles_settings.xml @@ -0,0 +1,6 @@ + + + + \ No newline at end of file diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/.idea/misc.xml b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/.idea/misc.xml new file mode 100644 index 0000000000000000000000000000000000000000..7b8a80e66be030b61da5d321cc524f6baa05e55d --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/.idea/misc.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/.idea/modules.xml b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/.idea/modules.xml new file mode 100644 index 0000000000000000000000000000000000000000..2f1207dcc229f7970e2a569be72b24fedf67db1f --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/.idea/workspace.xml b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/.idea/workspace.xml new file mode 100644 index 0000000000000000000000000000000000000000..270a094ac2f4e8a64858ac4a4fb2b535de4c89f9 --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/.idea/workspace.xml @@ -0,0 +1,130 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1639635291369 + + + + + + + + + + + + + + \ No newline at end of file diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/.keep b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/.keep new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/README.md b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..aadb08e6ac13b54c0cbf4afdc2efadbb1cdd6322 --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/README.md @@ -0,0 +1,199 @@ +- [基本信息](#基本信息.md) +- [概述](#概述.md) +- [训练环境准备](#训练环境准备.md) +- [快速上手](#快速上手.md) +- [迁移学习指导](#迁移学习指导.md) +- [高级参考](#高级参考.md) +

基本信息

+ +**发布者（Publisher）：Huawei** + +**应用领域（Application Domain）：Computer Version** + +**版本（Version）：1.1** + +**修改时间（Modified） ：2022.6.9** + +**大小（Size）：157MB** + +**框架（Framework）：TensorFlow 1.15.0** + +**模型格式（Model Format）：ckpt** + +**精度（Precision）：Mixed** + +**处理器（Processor）：昇腾910** + +**应用级别（Categories）：Research** + +**描述（Description）：基于TensorFlow框架的SfMLearner网络训练代码** + +

概述

+ +SfMLearner是一种针对单目深度即位姿估计的无监督学习框架。 + +- 参考论文： + + T H Zhou, M Brown, N Snavely, et al. Unsupervised Learning of Depth and Ego-Motion from Video[C]. IEEE Conference on Computer Vision and Pattern Recognition (CVPR), Hawaii, 2017, 6612-6621. + +- 参考实现： + + https://github.com/tinghuiz/SfMLearner + +- 适配昇腾 AI 处理器的实现： + + https://gitee.com/liu-jiaqiyu/ModelZoo-TensorFlow/tree/master/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow + + + + +## 默认配置 + +- 训练数据集预处理（以KITTI训练集为例，仅作为用户参考示例）： + + - 图像的输入尺寸为128*416 + +- 训练超参 + + - Batch size： 64 + - Learning rate： 0.0002 + - Seq length: 3 + - Train step: 200000 + + +## 支持特性 + +| 特性列表 | 是否支持 | +|-------|------| +| 分布式训练 | 否 | +| 混合精度 | 是 | +| 并行数据 | 是 | + +## 混合精度训练 + +昇腾910 AI处理器提供自动混合精度功能，可以针对全网中float32数据类型的算子，按照内置的优化策略，自动将部分float32的算子降低精度到float16，从而在精度损失很小的情况下提升系统性能并减少内存使用。 + +## 开启混合精度 + +脚本已默认开启混合精度，设置precision_mode参数的脚本参考如下。 + + ``` + custom_op = session_config.graph_options.rewrite_options.custom_optimizers.add() + custom_op.name = 'NpuOptimizer' + custom_op.parameter_map["precision_mode"].s = tf.compat.as_bytes(str(args.precision_mode)) + ``` + + +

训练环境准备

+ +- NPU环境： + + - NPU: 1*Ascend 910 + - CPU: 24*vCPUs 550GB + +- 第三方依赖 + + - scipy + + +

快速上手

+ +- 数据集准备 +1. 模型训练使用kitti_odometry数据集，已上传至obs中，obs路径如下：obs://sfm/KITTI/sequences/ + +## 模型训练 + +- 单击“立即下载”，并选择合适的下载方式下载源码包。 + +- 启动训练之前，首先要配置程序运行相关环境变量。 + + 环境变量配置信息参见： + + [Ascend 910训练平台环境变量设置](https://gitee.com/ascend/modelzoo/wikis/Ascend%20910%E8%AE%AD%E7%BB%83%E5%B9%B3%E5%8F%B0%E7%8E%AF%E5%A2%83%E5%8F%98%E9%87%8F%E8%AE%BE%E7%BD%AE?sort_id=3148819) + + +1. 训练命令 + + ``` + python3.7 ./train.py --dataset_dir=${data_path}'data' --checkpoint_dir=${output_path}'output/' --img_width=416 --image_height=128 --batch_size=4 + ``` + +2. 测试命令 + + ``` + python3.7 ./test_kitti_pose.py --test_seq=10 --dataset_dir=${data_path} --output_dir=${output_path}'kitti_eval/pose_data/ours_results/' --ckpt_file=${output_path}'output/model-199545' + ``` + +3. 验证指令 + + ``` + python3.7 ./kitti_eval/eval_pose.py --gtruth_dir=${output_path}'kitti_eval/pose_data/ground_truth/10/' --pred_dir=${output_path}'kitti_eval/pose_data/ours_results/' + ``` + + +

迁移学习指导

+ +- 数据集准备。 + + 获取数据。请参见“快速上手”中的数据集准备 + +- 模型训练。 + + 参考“模型训练”中训练步骤。 + +- 模型测试。 + + 参考“模型训练”中测试步骤。 + +- 模型评估。 + + 参考“模型训练”中验证步骤。 + + +

高级参考

+ +## 脚本和示例代码 + +``` +├── SfMLearner.py //网络训练与测试代码 +├── README.md //代码说明文档 +├── data_loader.py //数据预处理代码 +├── demo.ipynb //可视化代码 +├── nets.py //深度和位姿网络搭建代码 +├── train.py //训练代码 +├── test_kitti_depth.py //深度测试代码 +├── test_kitti_pose.py //位姿测试代码 +├── utils.py //常用功能函数代码（如旋转矩阵与欧拉角相互转换） +├── requirements.txt //训练python依赖列表 +├── test +│ ├──train_performance_1p.sh //单卡训练验证性能启动脚本 +│ ├──train_full_1p.sh //单卡全量训练启动脚本 + +``` + +1. 脚本参数 + +``` +--data_path 数据集路径，默认：path/data +--batch_size 每个NPU的batch size，默认：64 +--learing_rata 初始学习率，默认：0.0002 +``` + +2. 参考脚本的模型存储路径为./output/。参考脚本的模型日志路径为./log/，训练脚本log中包括如下信息。 +``` +Epoch: [ 1] [ 100/ 1255] time: 6.6796/it loss: 0.872 +Epoch: [ 1] [ 200/ 1255] time: 0.1960/it loss: 0.836 +Epoch: [ 1] [ 300/ 1255] time: 0.1956/it loss: 0.962 +Epoch: [ 1] [ 400/ 1255] time: 0.1944/it loss: 1.976 +Epoch: [ 1] [ 500/ 1255] time: 0.1934/it loss: 1.358 +Epoch: [ 1] [ 600/ 1255] time: 0.1952/it loss: 1.569 +Epoch: [ 1] [ 700/ 1255] time: 0.1945/it loss: 1.443 +Epoch: [ 1] [ 800/ 1255] time: 0.1951/it loss: 1.475 +Epoch: [ 1] [ 900/ 1255] time: 0.1945/it loss: 1.223 +Epoch: [ 1] [ 1000/ 1255] time: 0.1955/it loss: 1.542 +Epoch: [ 1] [ 1100/ 1255] time: 0.1949/it loss: 1.318 +Epoch: [ 1] [ 1200/ 1255] time: 0.1945/it loss: 1.212 + [*] Saving checkpoint to /home/ma-user/modelarts/outputs/train_url_0/output/... +``` + + diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/SfMLearner.py b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/SfMLearner.py new file mode 100644 index 0000000000000000000000000000000000000000..8562d4eeb0a4777f845c67ca10cf4d30ec3d87fd --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/SfMLearner.py @@ -0,0 +1,378 @@ +# +# Copyright 2017 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from __future__ import division +from npu_bridge.npu_init import * +import os +import time +import math +import numpy as np +import tensorflow as tf +import tensorflow.contrib.slim as slim +from data_loader import DataLoader +from nets import * +from utils import * +# flags = tf.app.flags.FLAGS +# flags.DEFINE_string("num_source", None, "add configuration") +class SfMLearner(object): + def __init__(self): + self.image_iterator = None + self.cam_iterator = None + #pass + + def build_train_graph(self): + opt = self.opt + loader = DataLoader(opt.dataset_dir, + opt.batch_size, + opt.img_height, + opt.img_width, + opt.num_source, + opt.num_scales) + with tf.name_scope("data_loading"): + tgt_image, src_image_stack, intrinsics, ds_image_iterator, ds_cam_iterator = loader.load_train_batch() + tgt_image = self.preprocess_image(tgt_image) + src_image_stack = self.preprocess_image(src_image_stack) + self.image_iterator = ds_image_iterator + self.cam_iterator = ds_cam_iterator + + with tf.name_scope("depth_prediction"): + pred_disp, depth_net_endpoints = disp_net(tgt_image, + is_training=True) + pred_depth = [1./d for d in pred_disp] + + with tf.name_scope("pose_and_explainability_prediction"): + pred_poses, pred_exp_logits, pose_exp_net_endpoints = \ + pose_exp_net(tgt_image, + src_image_stack, + do_exp=(opt.explain_reg_weight > 0), + is_training=True) + + with tf.name_scope("compute_loss"): + pixel_loss = 0 + exp_loss = 0 + smooth_loss = 0 + tgt_image_all = [] + src_image_stack_all = [] + proj_image_stack_all = [] + proj_error_stack_all = [] + exp_mask_stack_all = [] + for s in range(opt.num_scales): + if opt.explain_reg_weight > 0: + # Construct a reference explainability mask (i.e. all + # pixels are explainable) + ref_exp_mask = self.get_reference_explain_mask(s) + # Scale the source and target images for computing loss at the + # according scale. + curr_tgt_image = tf.image.resize_area(tgt_image, + [int(opt.img_height/(2**s)), int(opt.img_width/(2**s))]) + curr_src_image_stack = tf.image.resize_area(src_image_stack, + [int(opt.img_height/(2**s)), int(opt.img_width/(2**s))]) + + if opt.smooth_weight > 0: + smooth_loss += opt.smooth_weight/(2**s) * \ + self.compute_smooth_loss(pred_disp[s]) + + for i in range(opt.num_source): + # Inverse warp the source image to the target image frame + curr_proj_image = projective_inverse_warp( + curr_src_image_stack[:,:,:,3*i:3*(i+1)], + tf.squeeze(pred_depth[s], axis=3), + pred_poses[:,i,:], + intrinsics[:,s,:,:]) + curr_proj_error = tf.abs(curr_proj_image - curr_tgt_image) + # Cross-entropy loss as regularization for the + # explainability prediction + if opt.explain_reg_weight > 0: + curr_exp_logits = tf.slice(pred_exp_logits[s], + [0, 0, 0, i*2], + [-1, -1, -1, 2]) + exp_loss += opt.explain_reg_weight * \ + self.compute_exp_reg_loss(curr_exp_logits, + ref_exp_mask) + curr_exp = tf.nn.softmax(curr_exp_logits) + # Photo-consistency loss weighted by explainability + if opt.explain_reg_weight > 0: + pixel_loss += tf.reduce_mean(curr_proj_error * \ + tf.expand_dims(curr_exp[:,:,:,1], -1)) + else: + pixel_loss += tf.reduce_mean(curr_proj_error) + # Prepare images for tensorboard summaries + if i == 0: + proj_image_stack = curr_proj_image + proj_error_stack = curr_proj_error + if opt.explain_reg_weight > 0: + exp_mask_stack = tf.expand_dims(curr_exp[:,:,:,1], -1) + else: + proj_image_stack = tf.concat([proj_image_stack, + curr_proj_image], axis=3) + proj_error_stack = tf.concat([proj_error_stack, + curr_proj_error], axis=3) + if opt.explain_reg_weight > 0: + exp_mask_stack = tf.concat([exp_mask_stack, + tf.expand_dims(curr_exp[:,:,:,1], -1)], axis=3) + tgt_image_all.append(curr_tgt_image) + src_image_stack_all.append(curr_src_image_stack) + proj_image_stack_all.append(proj_image_stack) + proj_error_stack_all.append(proj_error_stack) + if opt.explain_reg_weight > 0: + exp_mask_stack_all.append(exp_mask_stack) + total_loss = pixel_loss + smooth_loss + exp_loss + + with tf.name_scope("train_op"): + train_vars = [var for var in tf.trainable_variables()] + optim = tf.train.AdamOptimizer(opt.learning_rate, opt.beta1) + # loss_scale_opt = optim # added # deleted + # loss_scale_manager = ExponentialUpdateLossScaleManager(init_loss_scale = 2 ** 32, incr_every_n_steps = 1000, decr_every_n_nan_or_inf = 2, decr_ratio = 0.5) # added # deleted + # optim = NPULossScaleOptimizer(loss_scale_opt, loss_scale_manager) # added # deleted + # self.grads_and_vars = optim.compute_gradients(total_loss, + # var_list=train_vars) + # self.train_op = optim.apply_gradients(self.grads_and_vars) + self.train_op = slim.learning.create_train_op(total_loss, optim) + self.global_step = tf.Variable(0, + name='global_step', + trainable=False) + self.incr_global_step = tf.assign(self.global_step, + self.global_step+1) + + # Collect tensors that are useful later (e.g. tf summary) + self.pred_depth = pred_depth + self.pred_poses = pred_poses + self.steps_per_epoch = loader.steps_per_epoch + self.total_loss = total_loss + self.pixel_loss = pixel_loss + self.exp_loss = exp_loss + self.smooth_loss = smooth_loss + self.tgt_image_all = tgt_image_all + self.src_image_stack_all = src_image_stack_all + self.proj_image_stack_all = proj_image_stack_all + self.proj_error_stack_all = proj_error_stack_all + self.exp_mask_stack_all = exp_mask_stack_all + + def get_reference_explain_mask(self, downscaling): + opt = self.opt + tmp = np.array([0,1]) + ref_exp_mask = np.tile(tmp, + (opt.batch_size, + int(opt.img_height/(2**downscaling)), + int(opt.img_width/(2**downscaling)), + 1)) + ref_exp_mask = tf.constant(ref_exp_mask, dtype=tf.float32) + return ref_exp_mask + + def compute_exp_reg_loss(self, pred, ref): + l = tf.nn.softmax_cross_entropy_with_logits( + labels=tf.reshape(ref, [-1, 2]), + logits=tf.reshape(pred, [-1, 2])) + return tf.reduce_mean(l) + + def compute_smooth_loss(self, pred_disp): + def gradient(pred): + D_dy = pred[:, 1:, :, :] - pred[:, :-1, :, :] + D_dx = pred[:, :, 1:, :] - pred[:, :, :-1, :] + return D_dx, D_dy + dx, dy = gradient(pred_disp) + dx2, dxdy = gradient(dx) + dydx, dy2 = gradient(dy) + return tf.reduce_mean(tf.abs(dx2)) + \ + tf.reduce_mean(tf.abs(dxdy)) + \ + tf.reduce_mean(tf.abs(dydx)) + \ + tf.reduce_mean(tf.abs(dy2)) + + def collect_summaries(self): + opt = self.opt + tf.summary.scalar("total_loss", self.total_loss) + tf.summary.scalar("pixel_loss", self.pixel_loss) + tf.summary.scalar("smooth_loss", self.smooth_loss) + tf.summary.scalar("exp_loss", self.exp_loss) + for s in range(opt.num_scales): + tf.summary.histogram("scale%d_depth" % s, self.pred_depth[s]) + tf.summary.image('scale%d_disparity_image' % s, 1./self.pred_depth[s]) + tf.summary.image('scale%d_target_image' % s, \ + self.deprocess_image(self.tgt_image_all[s])) + for i in range(opt.num_source): + if opt.explain_reg_weight > 0: + tf.summary.image( + 'scale%d_exp_mask_%d' % (s, i), + tf.expand_dims(self.exp_mask_stack_all[s][:,:,:,i], -1)) + tf.summary.image( + 'scale%d_source_image_%d' % (s, i), + self.deprocess_image(self.src_image_stack_all[s][:, :, :, i*3:(i+1)*3])) + tf.summary.image('scale%d_projected_image_%d' % (s, i), + self.deprocess_image(self.proj_image_stack_all[s][:, :, :, i*3:(i+1)*3])) + tf.summary.image('scale%d_proj_error_%d' % (s, i), + self.deprocess_image(tf.clip_by_value(self.proj_error_stack_all[s][:,:,:,i*3:(i+1)*3] - 1, -1, 1))) + tf.summary.histogram("tx", self.pred_poses[:,:,0]) + tf.summary.histogram("ty", self.pred_poses[:,:,1]) + tf.summary.histogram("tz", self.pred_poses[:,:,2]) + tf.summary.histogram("rx", self.pred_poses[:,:,3]) + tf.summary.histogram("ry", self.pred_poses[:,:,4]) + tf.summary.histogram("rz", self.pred_poses[:,:,5]) + # for var in tf.trainable_variables(): + # tf.summary.histogram(var.op.name + "/values", var) + # for grad, var in self.grads_and_vars: + # tf.summary.histogram(var.op.name + "/gradients", grad) + + def train(self, opt): + opt.num_source = opt.seq_length - 1 + # TODO: currently fixed to 4 + opt.num_scales = 4 + self.opt = opt + self.build_train_graph() + self.collect_summaries() + with tf.name_scope("parameter_count"): + parameter_count = tf.reduce_sum([tf.reduce_prod(tf.shape(v)) \ + for v in tf.trainable_variables()]) + self.saver = tf.train.Saver([var for var in tf.model_variables()] + \ + [self.global_step], + max_to_keep=10) + sv = tf.train.Supervisor(logdir=opt.checkpoint_dir, + save_summaries_secs=0, + saver=None) + config = tf.ConfigProto() + config.gpu_options.allow_growth = True + with sv.managed_session(config=npu_config_proto(config_proto=config)) as sess: + sess.run(self.image_iterator.initializer) + sess.run(self.cam_iterator.initializer) + print('Trainable variables: ') + for var in tf.trainable_variables(): + print(var.name) + print("parameter_count =", sess.run(parameter_count)) + if opt.continue_train: + if opt.init_checkpoint_file is None: + checkpoint = tf.train.latest_checkpoint(opt.checkpoint_dir) + else: + checkpoint = opt.init_checkpoint_file + print("Resume training from previous checkpoint: %s" % checkpoint) + self.saver.restore(sess, checkpoint) + start_time = time.time() + for step in range(1, opt.max_steps): + fetches = { + "train": self.train_op, + "global_step": self.global_step, + "incr_global_step": self.incr_global_step + } + + if step % opt.summary_freq == 0: + fetches["loss"] = self.total_loss + fetches["summary"] = sv.summary_op + + results = sess.run(fetches) + gs = results["global_step"] + + if step % opt.summary_freq == 0: + sv.summary_writer.add_summary(results["summary"], gs) + train_epoch = math.ceil(gs / self.steps_per_epoch) + train_step = gs - (train_epoch - 1) * self.steps_per_epoch + print("Epoch: [%2d] [%5d/%5d] time: %4.4f/it loss: %.3f" \ + % (train_epoch, train_step, self.steps_per_epoch, \ + (time.time() - start_time)/opt.summary_freq, + results["loss"])) + start_time = time.time() + + if step % opt.save_latest_freq == 0: + self.save(sess, opt.checkpoint_dir, 'latest') + + if step % self.steps_per_epoch == 0: + self.save(sess, opt.checkpoint_dir, gs) + + def build_depth_test_graph(self): + input_uint8 = tf.placeholder(tf.uint8, [self.batch_size, + self.img_height, self.img_width, 3], name='raw_input') + input_mc = self.preprocess_image(input_uint8) + with tf.name_scope("depth_prediction"): + pred_disp, depth_net_endpoints = disp_net( + input_mc, is_training=False) + pred_depth = [1./disp for disp in pred_disp] + pred_depth = pred_depth[0] + self.inputs = input_uint8 + self.pred_depth = pred_depth + self.depth_epts = depth_net_endpoints + + def build_pose_test_graph(self): + input_uint8 = tf.placeholder(tf.uint8, [self.batch_size, + self.img_height, self.img_width * self.seq_length, 3], + name='raw_input') + input_mc = self.preprocess_image(input_uint8) + loader = DataLoader() + tgt_image, src_image_stack = \ + loader.batch_unpack_image_sequence( + input_mc, self.img_height, self.img_width, self.num_source) + with tf.name_scope("pose_prediction"): + pred_poses, _, _ = pose_exp_net( + tgt_image, src_image_stack, do_exp=False, is_training=False) + self.inputs = input_uint8 + self.pred_poses = pred_poses + + def preprocess_image(self, image): + # Assuming input image is uint8 + image = tf.image.convert_image_dtype(image, dtype=tf.float32) + return image * 2. -1. + + def deprocess_image(self, image): + # Assuming input image is float32 + image = (image + 1.)/2. + return tf.image.convert_image_dtype(image, dtype=tf.uint8) + + def setup_inference(self, + img_height, + img_width, + mode, + seq_length=3, + batch_size=1): + self.img_height = img_height + self.img_width = img_width + self.mode = mode + self.batch_size = batch_size + if self.mode == 'depth': + self.build_depth_test_graph() + if self.mode == 'pose': + self.seq_length = seq_length + self.num_source = seq_length - 1 + self.build_pose_test_graph() + + def inference(self, inputs, sess, mode='depth'): + fetches = {} + if mode == 'depth': + fetches['depth'] = self.pred_depth + if mode == 'pose': + fetches['pose'] = self.pred_poses + results = sess.run(fetches, feed_dict={self.inputs:inputs}) + return results + + def save(self, sess, checkpoint_dir, step): + model_name = 'model' + print(" [*] Saving checkpoint to %s..." % checkpoint_dir) + if step == 'latest': + self.saver.save(sess, + os.path.join(checkpoint_dir, model_name + '.latest')) + else: + self.saver.save(sess, + os.path.join(checkpoint_dir, model_name), + global_step=step) + diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/data_loader.py b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/data_loader.py new file mode 100644 index 0000000000000000000000000000000000000000..aa97a5a5ab7772cb1059c18940698b63bf821cc0 --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/data_loader.py @@ -0,0 +1,244 @@ +# +# Copyright 2017 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from __future__ import division +from npu_bridge.npu_init import * +import os +import random +import tensorflow as tf + +class DataLoader(object): + def __init__(self, + dataset_dir=None, + batch_size=None, + img_height=None, + img_width=None, + num_source=None, + num_scales=None): + self.dataset_dir = dataset_dir + self.batch_size = batch_size + self.img_height = img_height + self.img_width = img_width + self.num_source = num_source + self.num_scales = num_scales + + def load_train_batch(self): + """Load a batch of training instances. + """ + seed = random.randint(0, 2**31 - 1) + # Load the list of training files into queues + file_list = self.format_file_list(self.dataset_dir, 'train') + #image_paths_queue = tf.train.string_input_producer( + # file_list['image_file_list'], + # seed=seed, + # shuffle=True) + #cam_paths_queue = tf.train.string_input_producer( + # file_list['cam_file_list'], + # seed=seed, + # shuffle=True) + self.steps_per_epoch = int( + len(file_list['image_file_list'])//self.batch_size) + + # Load images + # img_reader = tf.WholeFileReader() # deleted + # _, image_contents = img_reader.read(image_paths_queue) # changed + def parse_image(image_path): # added + image_contents = tf.io.read_file(image_path) # added + image_seq = tf.image.decode_jpeg(image_contents) # " " was added + tgt_image, src_image_stack = self.unpack_image_sequence( # " " was added + image_seq, self.img_height, self.img_width, self.num_source) # " " was added + return src_image_stack, tgt_image # added + + # Load camera intrinsics + # cam_reader = tf.TextLineReader() # deleted + # _, raw_cam_contents = cam_reader.read(cam_paths_queue) # changed + def parse_cam(line): # added + rec_def = [] # " " was added + for i in range(9): # " " was added + rec_def.append([1.]) # " " was added + raw_cam_vec = tf.decode_csv(line, # " " was added + record_defaults=rec_def) # " " was added + raw_cam_vec = tf.stack(raw_cam_vec) # " " was added + intrinsics = tf.reshape(raw_cam_vec, [3, 3]) # " " was added + return intrinsics # added + + ds_image = tf.data.Dataset.from_tensor_slices(file_list['image_file_list']).repeat() # added + ds_image = ds_image.map(lambda image_path: parse_image(image_path), num_parallel_calls=64) # added + ds_image = ds_image.batch(self.batch_size, drop_remainder=True).prefetch(64) # added + ds_image_iterator = ds_image.make_initializable_iterator() # added + src_image_stack, tgt_image = ds_image_iterator.get_next() # added + ds_cam = tf.data.TextLineDataset(file_list['cam_file_list']).repeat() # added + ds_cam = ds_cam.map(parse_cam, num_parallel_calls=64) # added + ds_cam = ds_cam.batch(self.batch_size, drop_remainder=True).prefetch(64) # added + ds_cam_iterator = ds_cam.make_initializable_iterator() # added + intrinsics = ds_cam_iterator.get_next() # added + + # Form training batches + # src_image_stack, tgt_image, intrinsics = \ + # tf.train.batch([src_image_stack, tgt_image, intrinsics], + # batch_size=self.batch_size) + + # Data augmentation + image_all = tf.concat([tgt_image, src_image_stack], axis=3) + image_all, intrinsics = self.data_augmentation( + image_all, intrinsics, self.img_height, self.img_width) + tgt_image = image_all[:, :, :, :3] + src_image_stack = image_all[:, :, :, 3:] + intrinsics = self.get_multi_scale_intrinsics( + intrinsics, self.num_scales) + return tgt_image, src_image_stack, intrinsics, ds_image_iterator, ds_cam_iterator + + def make_intrinsics_matrix(self, fx, fy, cx, cy): + # Assumes batch input + batch_size = fx.get_shape().as_list()[0] + zeros = tf.zeros_like(fx) + r1 = tf.stack([fx, zeros, cx], axis=1) + r2 = tf.stack([zeros, fy, cy], axis=1) + r3 = tf.constant([0.,0.,1.], shape=[1, 3]) + r3 = tf.tile(r3, [batch_size, 1]) + intrinsics = tf.stack([r1, r2, r3], axis=1) + return intrinsics + + def data_augmentation(self, im, intrinsics, out_h, out_w): + # Random scaling + def random_scaling(im, intrinsics): + batch_size, in_h, in_w, _ = im.get_shape().as_list() + scaling = tf.random_uniform([2], 1, 1.15) + x_scaling = scaling[0] + y_scaling = scaling[1] + out_h = tf.cast(in_h * y_scaling, dtype=tf.int32) + out_w = tf.cast(in_w * x_scaling, dtype=tf.int32) + print(im) + print(scaling) + print(in_h) + print(in_w) + print(out_h) + print(out_w) + im = tf.image.resize_area(im, [out_h, out_w]) + print(im) + fx = intrinsics[:,0,0] * x_scaling + fy = intrinsics[:,1,1] * y_scaling + cx = intrinsics[:,0,2] * x_scaling + cy = intrinsics[:,1,2] * y_scaling + intrinsics = self.make_intrinsics_matrix(fx, fy, cx, cy) + return im, intrinsics + + # Random cropping + def random_cropping(im, intrinsics, out_h, out_w): + # batch_size, in_h, in_w, _ = im.get_shape().as_list() + batch_size, in_h, in_w, _ = tf.unstack(tf.shape(im)) + offset_y = tf.random_uniform([1], 0, in_h - out_h + 1, dtype=tf.int32)[0] + offset_x = tf.random_uniform([1], 0, in_w - out_w + 1, dtype=tf.int32)[0] + im = tf.image.crop_to_bounding_box( + im, offset_y, offset_x, out_h, out_w) + fx = intrinsics[:,0,0] + fy = intrinsics[:,1,1] + cx = intrinsics[:,0,2] - tf.cast(offset_x, dtype=tf.float32) + cy = intrinsics[:,1,2] - tf.cast(offset_y, dtype=tf.float32) + intrinsics = self.make_intrinsics_matrix(fx, fy, cx, cy) + return im, intrinsics + im, intrinsics = random_scaling(im, intrinsics) + im, intrinsics = random_cropping(im, intrinsics, out_h, out_w) + im = tf.cast(im, dtype=tf.uint8) + return im, intrinsics + + def format_file_list(self, data_root, split): + with open(data_root + '/%s.txt' % split, 'r') as f: + frames = f.readlines() + subfolders = [x.split(' ')[0] for x in frames] + frame_ids = [x.split(' ')[1][:-1] for x in frames] + image_file_list = [os.path.join(data_root, subfolders[i], + frame_ids[i] + '.jpg') for i in range(len(frames))] + cam_file_list = [os.path.join(data_root, subfolders[i], + frame_ids[i] + '_cam.txt') for i in range(len(frames))] + all_list = {} + all_list['image_file_list'] = image_file_list + all_list['cam_file_list'] = cam_file_list + return all_list + + def unpack_image_sequence(self, image_seq, img_height, img_width, num_source): + # Assuming the center image is the target frame + tgt_start_idx = int(img_width * (num_source//2)) + tgt_image = tf.slice(image_seq, + [0, tgt_start_idx, 0], + [-1, img_width, -1]) + # Source frames before the target frame + src_image_1 = tf.slice(image_seq, + [0, 0, 0], + [-1, int(img_width * (num_source//2)), -1]) + # Source frames after the target frame + src_image_2 = tf.slice(image_seq, + [0, int(tgt_start_idx + img_width), 0], + [-1, int(img_width * (num_source//2)), -1]) + src_image_seq = tf.concat([src_image_1, src_image_2], axis=1) + # Stack source frames along the color channels (i.e. [H, W, N*3]) + src_image_stack = tf.concat([tf.slice(src_image_seq, + [0, i*img_width, 0], + [-1, img_width, -1]) + for i in range(num_source)], axis=2) + src_image_stack.set_shape([img_height, + img_width, + num_source * 3]) + tgt_image.set_shape([img_height, img_width, 3]) + return tgt_image, src_image_stack + + def batch_unpack_image_sequence(self, image_seq, img_height, img_width, num_source): + # Assuming the center image is the target frame + tgt_start_idx = int(img_width * (num_source//2)) + tgt_image = tf.slice(image_seq, + [0, 0, tgt_start_idx, 0], + [-1, -1, img_width, -1]) + # Source frames before the target frame + src_image_1 = tf.slice(image_seq, + [0, 0, 0, 0], + [-1, -1, int(img_width * (num_source//2)), -1]) + # Source frames after the target frame + src_image_2 = tf.slice(image_seq, + [0, 0, int(tgt_start_idx + img_width), 0], + [-1, -1, int(img_width * (num_source//2)), -1]) + src_image_seq = tf.concat([src_image_1, src_image_2], axis=2) + # Stack source frames along the color channels (i.e. [B, H, W, N*3]) + src_image_stack = tf.concat([tf.slice(src_image_seq, + [0, 0, i*img_width, 0], + [-1, -1, img_width, -1]) + for i in range(num_source)], axis=3) + return tgt_image, src_image_stack + + def get_multi_scale_intrinsics(self, intrinsics, num_scales): + intrinsics_mscale = [] + # Scale the intrinsics accordingly for each scale + for s in range(num_scales): + fx = intrinsics[:,0,0]/(2 ** s) + fy = intrinsics[:,1,1]/(2 ** s) + cx = intrinsics[:,0,2]/(2 ** s) + cy = intrinsics[:,1,2]/(2 ** s) + intrinsics_mscale.append( + self.make_intrinsics_matrix(fx, fy, cx, cy)) + intrinsics_mscale = tf.stack(intrinsics_mscale, axis=1) + return intrinsics_mscale diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/demo.ipynb b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/demo.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..da775821e06d8940e438b18a7787af80b4d97a4e --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/demo.ipynb @@ -0,0 +1,127 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "%pylab inline\n", + "from __future__ import division\n", + "import os\n", + "import numpy as np\n", + "import PIL.Image as pil\n", + "import tensorflow as tf\n", + "from SfMLearner import SfMLearner\n", + "from pylab import *\n", + "import matplotlib.pyplot as plt\n", + "from utils import normalize_depth_for_display\n", + "\n", + "img_height=128\n", + "img_width=416\n", + "ckpt_file = 'models/model-190532'\n", + "fh = open('misc/sample.png', 'rb')\n", + "I = pil.open(fh)\n", + "I = I.resize((img_width, img_height), pil.ANTIALIAS)\n", + "I = np.array(I)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "sfm = SfMLearner()\n", + "sfm.setup_inference(img_height,\n", + " img_width,\n", + " mode='depth')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Restoring parameters from models/model-190532\n" + ] + } + ], + "source": [ + "saver = tf.train.Saver([var for var in tf.model_variables()]) \n", + "with tf.Session() as sess:\n", + " saver.restore(sess, ckpt_file)\n", + " pred = sfm.inference(I[None,:,:,:], sess, mode='depth')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3EAAACYCAYAAABK12CbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figure(figsize=(15,15))\n", + "subplot(1,2,1); imshow(I)\n", + "subplot(1,2,2); imshow(normalize_depth_for_display(pred['depth'][0,:,:,0]))\n", + "print('1111111')\n", + "plt.savefig('/users/lzr2019040707014/SfMLearner-master/1.png')\n", + "print('2222222')\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/graph.pbtxt b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/graph.pbtxt new file mode 100644 index 0000000000000000000000000000000000000000..d92b4e96487af586eb8d969bab89c9441b7cf0de --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/graph.pbtxt @@ -0,0 +1,485149 @@ +node { + name: "data_loading/input_producer/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5020 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 5020 + } + } + string_val: "/users/lzr2019040707014/KITTI/data/01/000887.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000936.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000018.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000644.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000959.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000759.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000506.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001099.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000428.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001067.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000198.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000697.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000208.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000540.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000647.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000883.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000619.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000941.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000038.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000084.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000413.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000031.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000353.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000674.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000340.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000538.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000304.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000267.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000541.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000685.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001016.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000676.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000786.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000651.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000982.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000698.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000232.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000319.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000357.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000989.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000768.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000060.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001048.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000074.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001043.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000453.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000840.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000977.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001090.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000344.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000519.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001029.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000182.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000296.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000465.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000568.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000850.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000557.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000516.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000431.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001010.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000425.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000820.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000539.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000643.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000588.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000617.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000771.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001052.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000722.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000478.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001068.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000435.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000438.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000696.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000328.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000627.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000602.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000756.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000858.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000097.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000039.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000562.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000905.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000580.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000806.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000852.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000665.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000327.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000149.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000824.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000975.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001075.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001051.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000669.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000150.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000650.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000734.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000237.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000420.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000726.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000293.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000059.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000175.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000497.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000275.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000028.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000424.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000137.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000979.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000772.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000785.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000210.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000209.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000550.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000299.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000315.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000509.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000961.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001037.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000346.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000844.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000944.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000940.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000828.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000002.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000642.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000920.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000244.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000560.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000955.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000856.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000396.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000632.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000800.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000452.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000218.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000345.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000067.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001059.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000873.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001070.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000197.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000342.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000179.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000446.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000243.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000719.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000037.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000072.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000711.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000797.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000006.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000690.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000483.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000110.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000524.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000221.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000995.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000992.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000454.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000760.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001096.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000962.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000996.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000543.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000821.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000595.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000131.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001083.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000492.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000274.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000872.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000667.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000251.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000815.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000390.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001039.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001033.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000520.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000661.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000259.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000144.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000270.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000192.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000811.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000720.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000289.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000281.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000491.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000783.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000288.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000537.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000729.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000638.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001095.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001078.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000358.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000816.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000201.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000200.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000793.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001002.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000374.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000636.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000874.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001019.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000058.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000226.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000809.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000214.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000121.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000011.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000547.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000046.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000561.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000126.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000045.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000566.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000202.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000932.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000659.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000938.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000320.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001042.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000671.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001020.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000393.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001041.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000655.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000258.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000801.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000426.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000475.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000207.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000666.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000450.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001073.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000054.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000155.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000057.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000249.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000190.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000635.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000033.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000770.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000472.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001046.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000886.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000136.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000458.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000727.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000795.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000870.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000477.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000147.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000215.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000073.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000333.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000533.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000180.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000796.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001018.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001086.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000321.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000082.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000429.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000363.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000034.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000947.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000545.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000343.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000487.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000980.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000065.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000286.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000462.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001007.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000391.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000789.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000653.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000280.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000884.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000361.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000199.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000085.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000466.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000895.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000903.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000050.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001009.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000470.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000652.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000241.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000303.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000501.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000375.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000212.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000247.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000272.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000220.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000070.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000628.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000914.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000401.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000953.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000569.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001044.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000765.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000648.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000565.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000744.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000211.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001074.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001053.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000165.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000040.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000442.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000960.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000138.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000255.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000585.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000542.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000183.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000507.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000380.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000799.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000917.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000012.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000576.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001060.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000480.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000254.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000660.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000125.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000567.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000946.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001036.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000094.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000988.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000633.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000900.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000331.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000732.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000124.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000579.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000687.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000616.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000784.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000474.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000845.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000592.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000529.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000654.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000119.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000476.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000317.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000020.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001091.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000384.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000387.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000203.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000919.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000276.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000807.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000456.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000107.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000951.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000950.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000228.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000623.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000399.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000973.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000151.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000122.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000741.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000692.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000376.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000915.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000930.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000104.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000298.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000295.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000355.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000615.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000118.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000222.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000330.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000738.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000422.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000625.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000641.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000637.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001056.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000758.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000508.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000089.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000181.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000287.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000683.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000128.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000005.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000675.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000593.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000664.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000494.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000461.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000253.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000326.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000712.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000728.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000372.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000114.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000600.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000700.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001004.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000341.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000078.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000017.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000318.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000283.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000023.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000189.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000532.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000347.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000677.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001057.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000432.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000083.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000041.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000764.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000911.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000386.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000449.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000522.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000493.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000564.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000016.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000583.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000499.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000505.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000366.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000248.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000176.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000148.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000063.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000813.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000263.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000402.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000656.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000838.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000025.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000901.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000803.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001079.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000152.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000514.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000611.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000266.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000257.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001076.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000536.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000245.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000869.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000418.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000688.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000954.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000574.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000460.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000233.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000925.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000791.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000354.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000139.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001089.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000909.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000027.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000164.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001071.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000586.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000075.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000224.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000022.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000921.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000749.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000080.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000904.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001011.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000877.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000068.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000324.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000525.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000445.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000707.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000864.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000109.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000912.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000634.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000021.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000102.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000991.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000971.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000367.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000360.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001054.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000839.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000417.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000763.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000162.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000939.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000468.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000558.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000721.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000019.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000782.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000761.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000922.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001072.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000631.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000578.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000857.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000535.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000115.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000584.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000604.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000827.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000061.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000423.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000332.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000311.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000469.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000352.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000934.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001050.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000515.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000368.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000120.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000842.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000630.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000188.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000291.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000805.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000464.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000906.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000042.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000778.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001069.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000774.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000757.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001045.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001047.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000713.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000216.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000999.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000581.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000587.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001085.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000227.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000945.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000381.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000496.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000964.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000081.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000310.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001001.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000231.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000910.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000888.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000278.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000605.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000837.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000970.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000163.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000170.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001014.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000924.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000544.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000217.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000978.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000177.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000471.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001058.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000157.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000997.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000897.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000026.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000305.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000219.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000407.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000794.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000780.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000076.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000261.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001025.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000009.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000447.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000724.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000112.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000773.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001006.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000686.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000788.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000388.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000349.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000618.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001066.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000699.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000279.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000834.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000053.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000621.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000172.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000091.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000556.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000843.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000223.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000693.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000246.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000265.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000395.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000670.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000473.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000926.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000481.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000523.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000436.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000629.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000572.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000927.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000290.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000626.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000498.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000056.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000455.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000504.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000893.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000682.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000972.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000739.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000798.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000814.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000891.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000737.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000766.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000817.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000178.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000640.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000459.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000329.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000048.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000187.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000113.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000117.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000099.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001062.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000277.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000134.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000916.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000965.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000530.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000695.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000553.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000087.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000106.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000620.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000364.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000716.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000876.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000937.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000105.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000394.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001065.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000853.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000548.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000412.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000055.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001080.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001077.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000714.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000510.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000337.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000527.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000206.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000485.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000229.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000704.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000143.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000385.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000829.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000096.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000710.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000490.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000010.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000684.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000590.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000103.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000591.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000285.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000575.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000335.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000323.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000173.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000338.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000976.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001063.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000062.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000440.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000754.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001093.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001097.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000512.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000282.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000098.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000753.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000518.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000482.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000658.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000024.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000408.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000489.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000382.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000004.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000551.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000169.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000488.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000294.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000679.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000336.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000415.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000403.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001055.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000835.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001003.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000552.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000503.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000750.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000747.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000717.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000108.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000370.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000052.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000001.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000880.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000093.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000427.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000748.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000095.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000825.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000861.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000013.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000007.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000804.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000725.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000889.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000213.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000851.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000292.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000879.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000740.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000236.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000709.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001035.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000127.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000302.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000043.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000154.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000943.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000573.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000607.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000993.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000833.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000185.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000166.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000234.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000322.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000673.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000191.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000359.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000668.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000271.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000957.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000918.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000090.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000204.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000193.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000984.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000981.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001028.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000240.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000135.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000755.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000694.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001031.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000554.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000397.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000624.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000769.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001021.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000088.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000030.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000334.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000365.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000145.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000854.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000284.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000968.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000348.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000847.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000111.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000405.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000987.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000849.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000273.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000142.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001008.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000077.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000969.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000502.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001034.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000948.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000818.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000899.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000646.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000479.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000680.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000441.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001061.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000672.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000998.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000848.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000014.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000907.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000528.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000830.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000777.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000433.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000526.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001013.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000196.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000133.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000958.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000913.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000049.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000868.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000443.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000406.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000862.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000437.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000444.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000430.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000691.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000596.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000956.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000047.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000153.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000531.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000582.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000823.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000589.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000158.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000008.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001094.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000071.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000983.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000409.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000252.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000256.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000511.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000735.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000963.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000500.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000974.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000902.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000168.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000250.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000439.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000731.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000044.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001082.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000029.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001038.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000123.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001023.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000577.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000308.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000819.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000066.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000003.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000967.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000486.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000069.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000307.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000649.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001092.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000746.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000457.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000705.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000146.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001032.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000986.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001005.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000832.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000896.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000826.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000639.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000356.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000597.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000410.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000622.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000702.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000101.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000841.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000513.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000867.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000885.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000371.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001027.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000928.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000448.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000689.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000186.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000929.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000571.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000079.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000416.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000451.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001087.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000015.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000657.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001049.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000160.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000645.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000300.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000603.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000419.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000762.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000379.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000086.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000810.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000378.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000400.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000130.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000546.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000414.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001081.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000260.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000036.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000035.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000866.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000309.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000952.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000994.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000599.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000369.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000377.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000606.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001000.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000235.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000404.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000859.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000467.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000411.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000882.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000559.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000601.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000463.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000383.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000389.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000141.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000742.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000230.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000238.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000313.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/001026.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000171.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000549.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000064.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000242.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000129.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/01/000892.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001116.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000681.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002512.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000936.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003965.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002769.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000018.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004332.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000644.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001677.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000759.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001234.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003595.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001824.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004311.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002754.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004041.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000506.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002389.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003619.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001099.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003088.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003791.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001859.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000428.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002731.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000140.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001964.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003490.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004369.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002128.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004283.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001744.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000836.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001584.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002944.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003407.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001362.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003837.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003852.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002647.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001067.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000198.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002568.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004511.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004340.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003721.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002724.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002661.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001783.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001681.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000208.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000540.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002715.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001411.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000619.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002835.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000941.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001254.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004090.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000038.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001899.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002813.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002951.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000084.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003630.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003332.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002582.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000413.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002991.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002416.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004505.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003898.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000031.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001792.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003449.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004165.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000353.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001306.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001760.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000674.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004529.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003607.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003242.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000340.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002403.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000538.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003930.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000304.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002547.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003541.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002590.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004218.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002278.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001731.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000846.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000267.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003278.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000541.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002343.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001239.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000685.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001854.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001016.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000676.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000339.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000786.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001370.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003613.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002323.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004237.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004241.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001451.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000651.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002016.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000982.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001178.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001454.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003782.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001179.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003622.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003705.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003610.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003813.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004096.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002398.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003989.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001373.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002785.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001352.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003190.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004417.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003087.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000232.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001799.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001716.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000421.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003271.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001885.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000357.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003216.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003039.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002927.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003798.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003160.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004000.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003921.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003015.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000989.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001598.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003356.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002627.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001223.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002499.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003473.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001228.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000768.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002574.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002133.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001691.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004419.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000156.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001586.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000060.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002819.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002387.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001048.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001183.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004267.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003424.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000074.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003980.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001043.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001825.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004350.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003680.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001424.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003191.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000453.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002907.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001200.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001012.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003239.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001456.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000521.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002517.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004383.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001633.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003472.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003944.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003245.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001319.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002613.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001776.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002749.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001489.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000840.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003396.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002370.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000977.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003975.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001894.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004214.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004094.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001090.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003627.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000495.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003126.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001366.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003646.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000344.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003848.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004005.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003752.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000519.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001664.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003602.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004331.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001694.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003260.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002700.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001450.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002912.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004122.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003543.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001144.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001029.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003467.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000182.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004207.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004298.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001304.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003629.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002902.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002131.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003946.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001774.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000718.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004073.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001505.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000296.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001713.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000465.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003107.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002588.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001614.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000568.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000268.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003065.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001449.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001989.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000850.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002351.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001365.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002852.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001631.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004366.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003288.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003724.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002658.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002257.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003864.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004034.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001292.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001940.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002029.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000557.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002422.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002840.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004044.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004192.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003446.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001180.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002622.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003367.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001429.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002664.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001888.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000431.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001010.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002179.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000425.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000820.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001593.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004307.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001426.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004441.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003922.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000539.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001548.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000643.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001294.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004348.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000588.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002771.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001778.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000617.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001685.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003323.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004421.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003872.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000949.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002644.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001401.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001509.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001844.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000771.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001052.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001589.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003658.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003814.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001162.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001233.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003555.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000610.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003265.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003952.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003022.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001289.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004460.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000723.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001552.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002854.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000722.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003836.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002973.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000478.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001068.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002932.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002379.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004061.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000435.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002242.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003984.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001367.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002444.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000438.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003270.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003211.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001943.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002996.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003915.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000696.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000328.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001274.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000627.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001663.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001912.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002417.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004113.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003556.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002470.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004278.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002777.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002428.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002300.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002942.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001329.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002674.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000602.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004535.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000756.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003886.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004059.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003892.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001106.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001405.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001168.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001504.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002763.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000097.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001817.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004082.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001129.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003092.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000614.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000039.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000562.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000905.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002154.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003292.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003101.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004469.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000580.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001317.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000806.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001623.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003132.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002210.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002316.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001719.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002748.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001928.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002895.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004309.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000852.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000665.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003909.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000327.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004445.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000149.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002093.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000824.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003251.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004056.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002246.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000975.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003538.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001247.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001075.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001051.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000669.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001124.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001609.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002432.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000150.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001855.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002061.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000650.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000734.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003902.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001789.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002183.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002490.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002863.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000237.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000420.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003117.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001726.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001143.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001280.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003315.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003832.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000726.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003895.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001423.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000293.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000059.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001972.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002734.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000175.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004452.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001739.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003685.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000497.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000275.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000028.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002844.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001849.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000424.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002983.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001140.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003127.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000137.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002729.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001232.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003319.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000979.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002940.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000772.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000785.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001250.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001711.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001655.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004519.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004337.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003165.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002092.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002381.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001210.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003299.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002623.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000210.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001394.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003582.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003974.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001512.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000209.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000550.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003713.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002593.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002877.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002158.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000662.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001956.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000299.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002132.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001994.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001284.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001275.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000315.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004416.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001759.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000509.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004220.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000961.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001037.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002396.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000346.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004105.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003188.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000844.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001814.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002261.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000132.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003609.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002026.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001305.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000944.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003841.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000484.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003628.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002640.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000940.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000002.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004012.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002192.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000642.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002483.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003571.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000920.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003935.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000244.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000560.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003272.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003918.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003131.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000955.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004323.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004400.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002364.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002500.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004125.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004045.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003950.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004358.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003057.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000856.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000396.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003037.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003329.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003566.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001761.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003755.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000632.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004084.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003631.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004172.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003100.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004169.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003280.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004198.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000800.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000452.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004427.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000218.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003355.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002686.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003522.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002287.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003002.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001624.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001212.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003810.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002599.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004065.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002305.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001225.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000345.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001296.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002986.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000067.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002004.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001059.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000873.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003093.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002106.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002199.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003606.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004429.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002560.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004344.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002328.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001070.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001513.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000197.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000342.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002443.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000179.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004341.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001990.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003860.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000446.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000243.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003483.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002078.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002938.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004088.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003560.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003345.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000719.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004507.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002668.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004392.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002960.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000037.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003572.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004138.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000711.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000797.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002605.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002082.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000006.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000517.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000609.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000690.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003447.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003430.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000483.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000110.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002736.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003712.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001526.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001834.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003569.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004003.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002096.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002871.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002874.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003374.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002697.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000524.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001413.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003297.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003740.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003313.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002049.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002982.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002540.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004147.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001334.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003348.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001581.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002188.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000221.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001393.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001235.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003137.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002375.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002839.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003759.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003620.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004315.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004418.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000995.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003207.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002272.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002473.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002570.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001536.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003558.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002237.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003054.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003825.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001881.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000992.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004190.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001534.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000454.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001428.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000760.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000032.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003391.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001196.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003310.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002831.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003804.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004457.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003650.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001096.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003223.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001303.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003551.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000962.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001169.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000996.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001597.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004536.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001342.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000543.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003581.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003234.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002091.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001361.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003596.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000362.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003268.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003967.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000821.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004409.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002886.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002277.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000595.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002450.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000131.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001083.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002139.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003061.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000492.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002196.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002601.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002150.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004137.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003029.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004203.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001871.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002882.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003905.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000274.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001975.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003982.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000872.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002010.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003987.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000667.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000251.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003164.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000815.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000390.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001039.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004221.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001033.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003730.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003025.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000520.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002177.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001128.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002313.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004055.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001936.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003526.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000259.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001689.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003475.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002303.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003085.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003400.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000144.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001503.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000270.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003311.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004534.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002663.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002621.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004254.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002906.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001419.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001679.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002354.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004305.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004304.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002775.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000811.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000720.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003361.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000289.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003772.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000281.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003947.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004336.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003954.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002350.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000491.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001320.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001973.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001113.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002800.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000783.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002308.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000288.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004438.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003510.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004091.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002315.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003276.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004463.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001931.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001483.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001471.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003800.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001561.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002666.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004286.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003778.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003230.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003677.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002098.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001126.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002947.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004436.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002722.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000729.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003906.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003866.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004377.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003696.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003717.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003574.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000638.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001095.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004451.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004260.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001840.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003116.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001750.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001078.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004466.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003805.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000358.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000816.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003599.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004449.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000201.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000200.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002037.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003372.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003264.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001740.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003018.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001987.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002107.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000793.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003001.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001660.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002437.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002719.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003681.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000374.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001347.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002041.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000636.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001353.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003366.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001889.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001127.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002858.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004472.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003122.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001775.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002739.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002948.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000874.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003668.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004027.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004387.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002645.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001338.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003020.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002253.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001626.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001019.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003206.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003182.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000058.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004224.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002019.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000226.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004236.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003830.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000809.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000214.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002215.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003231.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002872.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004189.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003275.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000121.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004123.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002178.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001120.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000547.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002294.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002317.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001798.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003920.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003845.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004330.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002541.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001487.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000046.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002846.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001745.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002509.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003184.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004222.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000126.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003671.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000045.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004501.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001267.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001636.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002974.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001359.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001895.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001315.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002423.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000932.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003753.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000938.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001804.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003553.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000320.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002632.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003007.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003647.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003771.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002782.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001042.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000671.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001291.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003402.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001645.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001748.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004274.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002027.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001251.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001909.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003302.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004108.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003335.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001041.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003662.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001639.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002324.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003890.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004246.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000655.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001308.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000258.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000801.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000426.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001948.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002860.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003162.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001755.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004092.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003623.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002920.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000207.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001566.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002384.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000666.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003210.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002474.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000450.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003821.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003393.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001073.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003257.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000054.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004296.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001947.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001084.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003444.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000155.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004404.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003344.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002429.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003187.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000249.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002143.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002134.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003389.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001345.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003496.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000190.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001336.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000635.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003408.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001734.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002071.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000033.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003350.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003385.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000770.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001988.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002795.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002529.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003817.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002050.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002611.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002307.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000472.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001046.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003783.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003327.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000886.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001324.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001573.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000314.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002943.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004488.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003130.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000136.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002283.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000458.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003966.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004531.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002586.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002528.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000727.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002646.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002710.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001717.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002708.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000795.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002200.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001519.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002368.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002486.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001446.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000870.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000477.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001252.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003173.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000147.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000215.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000116.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003392.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003986.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003030.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003200.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000073.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001922.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003649.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001437.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002280.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001911.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003548.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002138.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000333.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000533.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001246.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000180.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004282.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003004.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002816.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003575.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002204.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003174.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001541.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004276.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001350.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003486.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001667.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000796.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002410.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001018.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002505.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002553.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001086.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002216.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002597.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003213.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004216.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003017.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001580.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001875.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001357.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000321.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002968.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000082.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000429.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003750.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001523.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001642.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002577.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001530.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000363.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002556.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003529.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003702.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002175.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003511.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001151.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000545.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000343.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001242.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000487.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001341.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000980.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003557.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002048.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002085.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001722.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000767.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003576.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004074.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000065.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000286.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003041.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001905.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002587.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003450.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002171.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003891.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003518.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003343.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002369.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002451.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000462.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001007.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002240.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001469.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000391.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004333.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002035.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002802.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001259.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004051.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002650.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001088.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003035.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000789.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000653.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000598.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000280.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003277.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003660.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003815.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002399.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000884.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000361.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000199.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000085.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004520.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004378.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002619.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002301.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000466.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000895.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003150.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001431.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002620.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001874.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002740.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002058.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004018.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004504.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002796.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002807.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000903.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000050.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001951.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002534.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001282.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001188.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001421.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003229.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002978.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004509.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001009.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001494.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004357.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002857.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002346.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000787.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000051.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002680.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003937.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000652.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003170.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001601.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002109.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000733.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000241.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001625.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000303.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003689.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003621.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003769.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001592.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001610.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002649.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002374.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000501.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001968.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004373.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000790.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001676.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003611.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000375.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001396.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000212.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000247.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001538.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002928.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003856.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003194.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004161.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002333.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003773.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002412.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002721.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003779.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003469.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004205.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002567.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001577.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002247.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002358.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000272.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003301.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001256.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001547.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003981.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001546.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002803.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000220.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003305.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003857.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001149.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003263.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001991.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004002.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001470.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004160.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000812.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001941.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004343.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004376.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003888.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004079.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002327.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004325.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002624.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001980.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002787.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001596.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001408.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003849.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000070.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000628.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002892.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001678.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002845.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002733.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002197.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002580.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001833.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002330.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003876.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003349.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002097.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002176.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000914.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002488.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002465.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003425.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001863.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002503.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001996.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002054.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001653.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000953.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000569.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004465.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003690.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002921.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002271.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001756.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002250.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002631.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001299.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001015.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001343.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001374.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003757.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002985.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004062.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001044.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001556.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000765.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000225.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001995.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000648.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000565.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004025.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000744.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001277.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003624.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003855.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003861.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000211.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000985.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002418.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004476.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002202.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003441.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001466.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002291.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003232.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002999.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002656.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003104.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004247.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004285.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001074.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004259.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004496.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002441.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001053.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000165.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002255.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002000.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003406.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002421.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002786.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003159.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001651.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002063.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003801.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000040.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003169.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000442.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003593.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003333.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002220.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001710.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002213.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004269.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001773.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003670.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003249.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000960.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003434.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003019.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001835.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002385.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002717.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002992.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003971.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003695.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002025.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001528.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003665.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004411.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003744.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001933.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002923.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002798.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003119.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000138.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004454.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001787.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004313.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000255.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001440.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001827.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000585.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000542.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003504.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000183.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002382.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001326.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003360.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004212.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000507.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002735.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000380.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004316.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002557.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004516.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000799.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001766.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000917.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001915.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004239.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004087.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004473.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000012.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000576.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003811.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002543.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001060.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003583.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004301.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003519.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001923.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001784.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000480.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000254.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004017.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003336.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003070.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000660.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001376.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001644.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002056.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003600.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003196.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002245.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003828.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002751.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000125.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001189.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000567.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000092.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001585.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002234.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000946.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001141.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001036.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002770.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002937.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001482.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000608.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004448.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004076.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000094.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001758.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003320.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000988.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003514.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001704.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003129.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001524.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000900.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001268.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001753.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000331.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000732.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004272.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001270.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002824.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003998.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001955.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001979.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000124.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001314.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002232.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003220.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001310.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001961.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000579.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002521.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002546.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000687.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002241.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003163.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002111.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004322.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002180.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001258.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003754.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001495.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000616.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001721.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004470.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002794.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002044.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003428.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002086.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003081.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002113.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002116.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003398.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003820.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001666.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000875.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002984.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001522.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002259.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001417.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001568.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000784.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001244.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000474.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000845.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003900.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004527.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000592.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002703.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004339.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001628.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002694.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003440.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002832.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002510.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000529.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004426.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000654.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004068.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000119.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000476.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002853.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000317.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001974.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002067.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001877.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001657.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002581.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003636.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001718.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001165.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004219.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000020.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003331.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003578.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001091.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001245.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001807.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004359.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004178.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003078.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002608.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001635.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003889.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002682.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000387.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001950.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002239.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002690.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001372.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002712.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001481.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001902.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003679.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004028.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003964.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003495.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003386.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000919.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000276.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000807.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000456.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001255.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003326.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003634.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002094.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002312.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002489.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003827.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001815.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002814.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004458.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004432.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001298.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001222.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001409.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001323.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000776.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000107.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001412.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003134.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001351.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000951.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000950.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003644.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003180.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002760.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002281.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002045.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001473.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000228.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001897.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003439.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003761.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000399.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003413.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004029.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000973.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000151.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004410.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003719.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003716.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003098.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000122.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000741.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004196.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003603.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003435.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000692.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000376.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003643.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003788.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004104.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001441.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004292.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000915.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003183.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000930.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004250.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004447.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001659.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003354.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004374.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002699.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001485.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002681.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001499.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001104.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002533.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000104.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000298.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003316.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004515.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002036.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003797.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000295.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003498.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000355.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003373.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002821.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001963.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001939.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004253.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002062.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001167.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000615.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000118.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001457.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002970.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002741.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001098.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002898.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003474.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003056.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004471.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001749.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000222.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003325.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002687.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001480.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004083.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002651.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001286.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001916.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004291.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004494.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001816.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001613.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003011.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000942.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001850.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002121.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003097.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004128.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000330.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003487.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000422.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001896.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002933.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004467.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002671.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000802.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002228.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002837.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000641.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002949.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004217.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002702.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002752.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000637.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001172.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001056.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000758.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000508.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001328.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002565.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003205.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000089.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002174.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000181.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002304.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002945.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002391.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003059.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001527.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002076.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001648.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000287.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003158.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002230.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003953.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004223.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001390.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004244.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002461.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002994.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001730.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001735.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000683.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000128.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003128.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001158.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002676.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000675.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003105.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003013.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002896.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004280.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002373.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000593.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001105.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003554.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001525.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002918.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003829.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002292.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000664.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002759.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001472.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002607.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001866.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000494.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004319.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004489.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003241.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001226.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004136.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003808.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003540.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000461.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004408.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002685.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004043.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003308.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004306.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001772.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003171.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000253.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000326.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002362.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003124.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002466.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001257.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000712.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002208.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000728.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003728.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002916.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001638.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003573.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001674.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000372.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000114.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002039.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001696.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002867.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002401.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001904.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000935.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002344.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002243.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001637.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004141.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001729.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002195.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002377.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000600.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004110.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001810.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001488.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000700.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001535.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001004.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003419.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003339.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000341.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002127.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001194.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003726.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001865.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003996.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003352.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002566.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000017.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003729.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003697.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002689.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003653.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004277.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001837.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002217.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000318.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001649.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001311.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001551.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001202.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002595.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004440.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000283.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004265.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001364.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000023.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004228.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003589.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003043.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002778.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002077.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000189.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004013.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002919.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003591.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001654.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001927.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001578.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002626.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001829.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003259.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002160.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003688.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002137.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002688.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000532.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003226.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001192.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000347.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003563.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002309.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003423.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002021.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002554.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002173.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003870.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003195.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001926.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003923.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000677.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004171.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001057.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001136.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001153.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001243.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000432.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002855.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000083.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002295.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000781.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002925.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004402.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000041.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002648.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000764.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003499.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001670.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002883.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000911.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001507.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001204.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002299.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001715.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002211.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000386.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000449.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000522.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001100.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000493.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000923.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002151.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002967.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004414.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002236.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003470.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000564.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000583.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003437.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001848.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000205.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000499.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001605.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003199.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003052.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002506.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002876.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000505.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002414.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004235.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002168.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000366.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002990.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002870.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001832.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002784.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002934.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000176.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001627.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002395.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002799.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002053.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004146.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002677.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002518.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002737.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003064.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002725.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002730.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004478.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003897.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000148.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004290.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002922.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003461.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002269.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003248.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000263.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002600.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003983.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003047.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003807.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001501.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000402.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003114.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003931.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002101.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003286.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004072.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002404.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002081.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002038.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003409.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004046.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003785.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003746.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003775.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001590.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001862.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003282.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003672.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002683.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000656.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002290.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000025.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001882.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001201.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001836.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004538.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000901.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002311.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000803.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001079.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002746.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003321.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003766.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001497.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001600.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000152.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003806.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001517.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004159.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002136.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003824.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003725.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000514.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004099.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002286.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003632.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002498.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004314.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000908.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001786.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002550.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001858.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003136.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001355.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002051.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002115.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004166.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000266.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001688.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000257.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003418.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000933.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002678.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001686.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002791.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003459.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004342.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001709.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002264.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004162.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002561.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003819.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004116.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003765.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003415.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001867.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000245.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000869.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001986.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000418.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001240.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000688.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002405.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003747.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003154.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000954.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000706.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004174.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002345.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000174.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002905.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000574.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000460.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002780.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002252.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000233.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003338.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001467.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000925.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000791.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004475.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002157.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001461.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000354.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000139.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003963.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003675.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001161.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004299.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004225.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002033.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004328.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001110.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003036.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001184.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004539.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003745.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001402.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000909.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003703.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002223.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001901.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000027.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000164.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001071.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002672.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003997.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000586.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004464.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000075.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002738.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001706.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003246.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002279.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000224.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004446.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004004.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003484.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001703.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003936.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004479.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004396.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001123.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001491.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003693.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004215.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003016.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002997.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002657.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002836.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001564.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002792.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002055.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000022.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002911.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000921.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001793.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002958.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003141.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000749.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000080.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000904.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001751.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000184.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002186.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001011.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000877.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002709.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002514.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002720.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004480.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001309.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003762.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002781.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002635.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000068.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000324.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004040.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003597.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001518.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002879.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001809.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004388.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002478.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002753.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000707.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001170.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003884.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004229.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000864.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001822.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000109.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004070.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001553.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000912.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002034.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000634.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003318.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001791.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001629.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000021.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003661.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000102.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003515.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000991.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004101.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000971.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004422.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000367.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001474.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000360.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004226.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001558.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001054.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000839.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000417.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003707.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003111.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001145.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001687.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002248.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003973.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001723.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002612.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001932.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003240.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001017.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003436.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003539.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003108.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004175.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001714.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003080.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000162.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003912.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000939.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001555.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000468.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003033.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000865.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002218.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001135.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000558.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002817.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002768.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000721.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002156.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003244.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001906.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000792.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001265.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000019.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004112.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001886.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004206.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003789.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000782.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002767.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000195.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003651.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001992.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003502.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000761.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000922.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001072.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002189.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000631.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001752.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000578.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002850.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000857.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004349.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000535.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000115.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003218.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004154.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004406.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003544.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001337.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003083.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000584.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002728.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000604.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002130.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001312.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003663.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001339.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003172.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003198.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003225.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002348.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004281.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004049.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000061.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000423.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000332.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004525.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003962.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000311.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001109.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004271.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000469.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003908.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004380.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001942.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000352.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000934.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003135.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002229.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002501.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004288.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002809.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002532.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002965.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003417.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002129.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001050.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002995.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004232.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003224.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000515.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002897.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003958.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003067.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003269.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001616.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004186.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000368.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002761.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001138.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000842.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003283.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002167.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002956.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000630.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003990.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004047.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000188.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000194.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002847.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003699.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003527.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002326.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003667.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000291.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001164.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001570.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000805.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000464.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002089.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001211.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002357.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001476.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001330.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002880.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004334.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000906.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000042.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000778.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002513.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001069.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002515.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001190.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003655.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000774.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002913.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000757.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002491.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001045.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001047.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003674.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001453.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003317.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000713.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001813.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001157.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002023.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000216.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003221.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003378.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003285.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003247.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003149.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003448.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004423.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001213.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001993.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004197.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002522.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002950.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003928.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003786.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003082.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001764.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003243.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001498.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002355.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003880.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004107.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004093.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000587.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001981.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002144.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001295.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003289.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001085.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000227.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000945.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002564.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003466.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003708.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001262.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003479.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000496.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004393.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002339.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003010.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001983.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002549.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000964.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001656.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001803.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000081.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003306.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004008.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001668.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002930.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002319.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000310.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001001.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003799.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004433.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002665.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003822.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004199.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000231.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000910.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001064.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002148.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002765.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003412.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000888.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004118.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001209.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002163.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000278.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000605.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003236.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001371.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003868.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004251.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003084.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000837.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001796.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003780.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001331.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000970.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003567.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002042.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000163.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001957.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004066.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001662.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001599.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001452.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003924.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001575.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003383.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001823.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001493.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002757.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000170.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003796.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002340.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001014.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001146.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001433.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000924.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003748.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000544.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001185.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003985.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003252.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003535.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004297.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003388.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000217.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003178.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004129.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001484.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002413.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000978.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000177.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002455.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000471.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002926.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003377.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001114.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001812.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003143.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001058.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000157.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003481.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002394.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002980.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001934.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004163.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004148.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001516.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000997.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001468.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002321.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001856.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003328.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000897.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001102.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003948.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004484.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004512.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001148.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003901.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001925.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003005.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002342.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001381.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000026.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003733.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003404.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000305.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002018.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002714.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000219.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004407.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003069.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000407.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003168.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004537.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000780.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002507.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002347.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001260.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003929.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003215.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002779.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001770.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000076.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001506.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001767.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002187.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003153.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003883.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002122.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003026.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000261.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001025.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002889.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001728.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000009.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003732.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003261.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003148.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002762.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002256.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000447.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001166.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000112.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004173.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002052.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001549.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002987.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000773.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002480.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002254.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003337.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003960.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001699.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003403.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003071.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001403.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002673.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004352.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001006.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002615.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003635.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001917.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000594.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003659.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001115.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000686.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001802.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003654.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001159.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001221.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000788.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000388.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004181.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002141.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004210.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004293.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000349.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004320.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001066.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000161.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004242.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003201.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001583.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001658.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002634.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003410.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000279.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001316.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002090.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002388.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003066.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002618.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000834.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003687.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003508.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004035.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003492.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002123.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000053.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004153.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003617.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004401.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000621.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002064.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000172.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000091.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000556.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003991.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002790.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001819.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004080.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002170.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000843.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000223.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002012.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003826.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000693.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004023.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002822.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001604.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000246.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003564.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002569.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002103.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003300.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001392.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002267.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003698.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003382.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003401.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002941.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002524.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001945.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003684.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004302.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001742.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002009.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001443.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000395.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000670.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002427.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002110.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002214.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002559.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004262.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002578.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003456.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000473.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004443.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002707.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004450.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002201.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001984.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000926.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003520.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002783.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004151.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003309.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000481.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000523.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003113.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002864.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003021.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002325.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000436.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003859.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000629.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003598.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000927.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003969.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001266.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003994.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001788.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000290.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001630.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003189.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003669.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004233.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000626.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001293.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000056.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000455.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002584.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004057.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003999.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002068.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001272.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003480.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002165.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003528.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001490.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000504.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003513.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002411.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003723.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002472.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002602.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002806.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003605.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002955.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001900.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004015.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001380.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001460.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000893.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001890.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000682.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004310.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003910.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000966.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000972.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002652.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003616.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002442.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000739.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000798.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002184.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000814.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003683.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002464.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003281.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001479.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000891.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004213.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000737.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003144.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002361.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002861.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001712.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002952.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002592.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003115.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004255.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000766.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002161.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000817.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002670.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000808.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000178.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002376.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003792.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000640.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003219.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003842.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003838.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003445.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003604.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003942.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003294.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003494.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003155.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003739.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004038.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000459.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000329.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004394.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002732.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000167.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001843.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002856.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001918.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003542.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000048.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000187.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003977.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003340.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004030.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001156.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001543.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003549.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000113.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003995.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003346.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000117.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003875.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002776.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001249.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004270.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004481.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002571.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002610.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000099.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001062.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003342.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002469.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001496.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000277.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003862.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002878.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000134.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000916.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001800.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003993.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002031.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003390.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001565.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002119.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000965.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003193.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001959.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000751.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004264.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004184.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001217.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003032.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002406.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001883.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000530.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001684.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003429.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004462.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002793.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001671.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001953.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000695.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000553.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003645.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003330.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001682.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004486.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001445.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001640.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001253.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002099.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002881.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002563.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004385.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000563.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003089.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002706.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003262.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002808.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002393.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002969.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002149.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003714.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003477.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000106.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001935.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001486.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003893.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003955.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000620.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002022.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002060.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003865.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001220.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000364.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001346.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000716.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004498.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000269.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000937.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002718.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003255.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004144.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002979.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002235.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001150.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000394.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001065.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000853.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002258.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003204.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000548.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003217.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002365.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000412.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002409.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002400.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003648.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002190.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001438.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001887.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000055.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002797.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001322.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002548.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001080.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001077.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001375.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002231.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002716.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002914.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002147.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003618.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003431.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000714.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002341.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002606.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000510.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001273.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001878.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004424.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004131.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003904.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004100.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002433.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004142.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002572.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002153.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002238.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004187.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002910.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002032.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001607.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001707.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004075.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000337.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000527.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000206.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004102.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000485.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002270.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001998.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004257.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004077.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004514.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004037.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000663.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001698.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000229.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002335.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004495.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004031.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002142.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002088.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004521.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003550.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001763.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001455.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000704.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000143.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003045.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000350.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001379.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002684.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001879.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002017.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002459.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003267.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004155.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002774.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001920.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001910.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002145.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004487.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001695.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002764.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002851.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001215.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002435.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003787.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002825.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000829.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001864.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002420.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001173.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000096.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000736.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003678.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003590.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000710.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001569.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002273.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003375.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001622.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003874.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003197.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000490.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002917.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001024.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001872.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004346.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002654.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001112.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000010.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002419.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001207.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004435.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000730.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001125.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002637.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003741.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001327.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003038.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002758.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000590.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003633.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000103.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001727.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002696.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003208.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001177.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002901.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003460.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003145.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004303.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001921.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004103.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003416.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000591.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000285.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000575.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000159.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004152.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003777.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003525.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004149.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000323.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000173.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003917.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001459.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003312.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003250.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001163.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003715.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001946.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000570.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003858.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004372.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003577.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000338.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000976.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002233.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001725.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004245.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004266.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001063.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002244.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001174.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003570.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002862.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002962.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000062.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001673.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001768.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002679.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003760.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002069.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001870.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000440.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000754.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004177.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002829.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003524.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002596.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004317.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001475.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001093.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000898.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002745.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001978.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003919.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003735.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004420.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001238.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002742.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001559.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001595.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003899.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000392.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001097.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003027.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001806.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003781.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000512.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002833.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004024.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001830.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003161.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003637.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003177.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002691.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000282.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002431.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002083.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003894.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004019.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003363.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004200.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002552.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003887.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004022.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001907.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000098.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003421.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003290.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004474.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001436.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003534.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000753.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002963.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000518.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002024.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003970.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003768.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001582.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003451.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000482.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000990.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000658.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001606.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002698.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003523.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000024.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003046.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001313.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002203.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001348.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004354.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001278.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004258.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002194.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000100.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000743.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000408.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002589.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002426.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002274.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003903.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003704.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004201.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003546.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001785.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002843.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002629.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001838.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001693.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003770.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002266.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002936.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003362.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001970.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004413.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001414.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001661.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003588.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004145.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000612.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000489.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004050.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003076.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002182.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000382.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004039.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000004.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000398.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001458.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001572.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002562.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001880.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004345.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003709.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002087.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003851.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004060.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002439.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001669.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000169.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001944.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002642.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000488.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002002.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004086.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002003.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004428.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001206.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001617.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004098.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003652.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004156.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002152.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003586.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002329.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001608.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003157.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002603.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000294.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000679.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001344.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004391.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000336.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003545.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002551.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001567.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002579.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003489.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003913.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000403.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000775.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001055.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002805.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000835.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001003.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001898.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002628.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000752.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000552.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001732.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001287.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000750.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002359.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000747.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002695.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004384.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001218.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000717.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002336.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004117.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004275.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002931.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000306.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002755.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002028.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002747.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004180.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000108.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001913.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003959.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001892.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000678.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002772.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003957.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000052.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004528.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003073.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000001.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000880.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000093.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000427.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004300.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001811.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000748.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000095.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002251.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001439.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003756.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001444.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002043.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003763.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002638.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002727.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000825.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004503.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001236.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004134.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003209.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003258.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002536.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003284.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004412.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003186.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002383.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002660.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003742.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001746.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002449.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004261.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002284.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004132.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000297.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002523.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003925.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003532.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003222.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004170.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002095.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002390.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001782.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000861.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000013.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001754.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001891.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000007.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003802.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000703.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001967.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000804.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004405.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002289.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002961.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000779.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000725.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000889.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001966.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000213.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003579.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004014.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003028.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002074.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001861.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003380.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003314.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002485.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000851.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003521.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001227.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003075.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000879.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002402.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001665.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001462.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003399.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002397.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000740.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002756.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003873.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002975.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000239.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001283.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003414.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001779.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002047.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000236.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000709.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001035.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000127.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001368.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001463.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002372.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002866.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003718.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002013.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003506.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002989.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003945.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002964.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001643.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002849.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000302.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001197.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004273.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000043.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004370.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002084.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001820.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004318.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002227.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004121.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002008.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003776.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001781.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000154.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002625.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002957.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000831.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003304.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004211.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004001.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003090.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004499.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003468.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004533.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004006.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002015.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004085.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004183.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000573.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004415.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004238.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001111.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001652.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000607.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003738.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004526.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000993.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002904.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000833.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003433.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003458.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002971.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004390.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000185.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002711.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002481.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002262.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003790.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002583.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001930.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000166.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001529.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000234.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002801.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001841.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003927.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003351.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003471.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000322.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000673.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001997.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004375.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002146.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003850.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000668.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004115.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003877.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003615.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003988.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000271.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001914.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002636.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000957.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003907.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004042.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000918.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002198.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003379.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003482.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003978.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001985.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002040.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004403.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002828.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004204.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000204.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001618.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002320.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003911.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001378.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004195.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001587.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001384.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000193.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004133.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002265.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003099.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000264.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002788.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004351.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003307.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000984.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002639.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000434.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001705.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002585.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000981.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001147.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001028.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000240.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002544.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002525.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003364.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001464.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002371.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003133.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001139.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001826.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002117.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000135.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000755.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000694.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002669.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001542.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001031.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002070.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001738.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000554.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003517.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003138.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000397.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004485.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003235.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002693.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000624.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004164.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000769.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004522.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001397.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004109.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002701.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003968.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000088.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000030.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000613.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003694.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001680.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002102.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002868.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003641.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000863.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004089.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000334.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002314.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001965.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003181.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000365.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000145.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001690.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003096.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000745.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000854.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001790.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002434.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001929.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002456.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001873.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002511.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003940.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002558.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000284.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002249.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002318.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003640.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001588.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000968.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001632.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002079.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004139.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000348.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002946.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003625.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001954.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004431.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000111.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000405.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002140.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000987.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003432.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003795.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003601.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000849.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001647.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003536.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000273.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003972.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002337.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001508.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002643.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004202.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000142.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003465.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001797.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001008.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002460.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003612.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003266.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000077.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000969.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003846.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003295.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004386.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002446.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003179.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000502.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002818.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001034.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002823.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000948.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004395.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003146.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001410.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002535.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004009.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002494.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001354.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002766.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000860.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002988.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002530.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000818.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001884.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003992.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002298.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003559.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000899.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003594.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000646.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000479.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000680.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003562.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002810.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002066.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003095.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002576.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000441.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004442.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002873.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002598.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001369.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003823.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001061.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000672.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000848.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003691.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001828.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003296.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003112.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000014.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002001.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000881.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000907.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000528.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000830.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002842.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004067.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001208.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001771.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004368.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000555.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002360.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002467.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000777.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003202.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000433.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000526.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003961.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001101.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003731.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004371.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001154.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004324.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004327.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002604.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000196.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000133.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000958.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004430.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003547.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001603.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001831.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001801.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002804.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002108.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002169.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003291.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001152.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001155.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000913.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001388.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001399.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003322.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001780.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004026.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003561.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004294.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001876.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000868.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001383.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001540.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000443.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001301.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003058.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004338.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003530.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000406.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000862.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001860.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000437.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002812.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000444.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003397.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000430.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003394.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002020.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000691.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001478.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004461.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001465.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000708.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003491.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001285.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002848.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000596.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002492.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004329.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003024.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001521.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004081.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002331.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002080.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003053.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003102.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002609.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000956.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002105.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002743.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000047.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000153.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001757.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000531.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003368.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004530.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004493.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003585.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002222.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001230.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002072.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001160.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003734.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001133.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002502.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003068.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004150.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004063.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000823.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004016.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002692.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003812.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003042.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003751.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002104.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003214.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000589.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003273.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001908.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003949.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000158.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001022.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001976.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003003.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002869.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000008.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003700.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001094.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004193.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003365.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004188.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001545.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004167.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004268.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003673.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004459.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001672.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000071.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001448.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000983.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000409.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003664.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001332.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001594.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002288.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001937.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004399.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002030.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003758.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001199.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003072.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002205.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000252.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003934.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001203.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003976.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001356.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003453.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000256.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000511.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002453.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002448.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003156.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000963.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001777.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000500.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003493.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002827.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001903.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002112.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000974.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003956.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003943.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001107.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003656.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004010.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000902.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002282.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004011.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000168.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000250.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003784.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003103.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002191.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003454.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002006.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004518.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003405.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003568.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004482.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001325.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003863.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001132.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002662.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000731.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000044.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001082.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003896.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004524.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002516.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001531.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003227.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003743.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001510.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000029.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001038.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000123.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001363.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002057.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004158.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001023.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000577.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004287.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003979.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003062.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001318.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001263.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003854.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001579.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003293.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003608.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003341.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000819.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003835.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003175.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004437.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000066.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002005.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003503.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004127.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000967.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001700.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002065.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000890.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001520.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003843.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004455.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004353.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003885.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000069.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000351.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000307.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004106.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000649.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001092.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002614.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000457.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002352.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000146.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002440.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003000.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001032.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003809.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004194.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004513.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004071.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002415.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002159.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003212.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000986.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001683.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001005.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000832.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003794.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000896.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001591.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003034.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003077.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004532.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002865.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000826.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000639.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000356.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001560.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003381.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000597.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000410.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003657.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000622.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003871.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002181.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004243.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000702.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003869.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003106.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000101.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001406.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001602.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003462.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001386.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003639.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002424.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004130.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000841.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000513.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004120.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001554.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000867.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002162.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000885.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001769.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004036.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003079.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002704.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003831.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003638.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000371.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003347.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003139.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001297.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002617.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003767.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001300.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000928.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003228.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004506.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001612.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002520.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001307.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001794.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001852.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002890.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000448.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000689.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000186.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002789.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000929.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004058.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001733.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004111.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003140.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000312.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004444.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002908.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004263.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001214.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001938.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003507.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002366.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002885.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004033.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000571.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000079.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002915.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003478.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002007.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004048.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004284.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003370.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001702.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002726.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000416.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000451.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001400.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002219.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002353.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002953.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004182.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002705.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001087.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004308.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000015.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003334.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000657.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001049.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001030.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002653.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004439.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004389.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002750.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003816.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000160.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000645.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002537.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001447.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004523.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003736.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001219.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003369.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003359.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002046.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002977.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002527.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004500.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003882.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003358.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003192.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000603.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002713.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000715.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000419.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001743.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001737.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000762.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000379.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002633.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003692.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003463.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003060.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002386.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001195.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001198.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003881.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000086.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002407.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000810.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000378.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001701.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002959.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004497.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004097.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002575.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002976.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003509.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002363.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003749.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003537.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000400.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004209.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003867.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003324.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000130.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002468.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004234.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000546.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003121.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000414.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001081.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000260.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000036.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004208.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000035.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000866.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003094.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000309.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001134.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003565.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001430.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001427.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004230.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000952.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001736.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000994.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003109.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001117.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003938.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001615.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004347.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002306.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000599.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000369.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000377.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000606.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001000.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001741.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000262.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000235.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002542.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003086.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002367.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001335.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000931.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000859.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003933.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000467.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001821.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000822.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000411.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000882.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001853.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002888.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003443.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001224.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004240.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004054.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000559.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002356.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002475.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004335.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002887.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002100.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002954.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000601.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001924.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003914.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000463.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002493.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003031.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002929.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001290.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000383.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/004363.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000389.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001241.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002591.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000141.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000742.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000230.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003592.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001205.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001697.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000313.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001026.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000171.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001181.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000549.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000064.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000242.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000129.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003711.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001248.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001237.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002482.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001650.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/000892.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/003238.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/002487.jpg" + string_val: "/users/lzr2019040707014/KITTI/data/00/001634.jpg" + } + } + } +} +node { + name: "data_loading/input_producer/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: 5020 + } + } + } +} +node { + name: "data_loading/input_producer/Greater/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: 0 + } + } + } +} +node { + name: "data_loading/input_producer/Greater" + op: "Greater" + input: "data_loading/input_producer/Size" + input: "data_loading/input_producer/Greater/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/input_producer/Assert/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: "string_input_producer requires a non-null input tensor" + } + } + } +} +node { + name: "data_loading/input_producer/Assert/Assert/data_0" + 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: "string_input_producer requires a non-null input tensor" + } + } + } +} +node { + name: "data_loading/input_producer/Assert/Assert" + op: "Assert" + input: "data_loading/input_producer/Greater" + input: "data_loading/input_producer/Assert/Assert/data_0" + attr { + key: "T" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "summarize" + value { + i: 3 + } + } +} +node { + name: "data_loading/input_producer/Identity" + op: "Identity" + input: "data_loading/input_producer/Const" + input: "^data_loading/input_producer/Assert/Assert" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5020 + } + } + } + } + } +} +node { + name: "data_loading/input_producer/RandomShuffle" + op: "RandomShuffle" + input: "data_loading/input_producer/Identity" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5020 + } + } + } + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 431779219 + } + } +} +node { + name: "data_loading/input_producer" + op: "FIFOQueueV2" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "capacity" + value { + i: 32 + } + } + attr { + key: "component_types" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "data_loading/input_producer/input_producer_EnqueueMany" + op: "QueueEnqueueManyV2" + input: "data_loading/input_producer" + input: "data_loading/input_producer/RandomShuffle" + attr { + key: "Tcomponents" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "timeout_ms" + value { + i: -1 + } + } +} +node { + name: "data_loading/input_producer/input_producer_Close" + op: "QueueCloseV2" + input: "data_loading/input_producer" + attr { + key: "cancel_pending_enqueues" + value { + b: false + } + } +} +node { + name: "data_loading/input_producer/input_producer_Close_1" + op: "QueueCloseV2" + input: "data_loading/input_producer" + attr { + key: "cancel_pending_enqueues" + value { + b: true + } + } +} +node { + name: "data_loading/input_producer/input_producer_Size" + op: "QueueSizeV2" + input: "data_loading/input_producer" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/input_producer/ToFloat" + op: "Cast" + input: "data_loading/input_producer/input_producer_Size" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/input_producer/mul/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.03125 + } + } + } +} +node { + name: "data_loading/input_producer/mul" + op: "Mul" + input: "data_loading/input_producer/ToFloat" + input: "data_loading/input_producer/mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/input_producer/fraction_of_32_full/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: "data_loading/input_producer/fraction_of_32_full" + } + } + } +} +node { + name: "data_loading/input_producer/fraction_of_32_full" + op: "ScalarSummary" + input: "data_loading/input_producer/fraction_of_32_full/tags" + input: "data_loading/input_producer/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/input_producer_1/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5020 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 5020 + } + } + string_val: "/users/lzr2019040707014/KITTI/data/01/000887_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000936_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000018_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000644_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000959_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000759_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000506_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001099_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000428_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001067_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000198_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000697_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000208_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000540_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000647_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000883_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000619_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000941_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000038_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000084_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000413_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000031_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000353_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000674_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000340_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000538_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000304_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000267_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000541_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000685_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001016_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000676_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000786_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000651_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000982_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000698_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000232_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000319_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000357_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000989_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000768_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000060_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001048_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000074_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001043_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000453_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000840_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000977_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001090_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000344_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000519_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001029_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000182_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000296_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000465_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000568_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000850_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000557_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000516_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000431_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001010_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000425_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000820_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000539_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000643_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000588_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000617_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000771_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001052_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000722_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000478_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001068_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000435_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000438_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000696_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000328_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000627_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000602_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000756_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000858_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000097_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000039_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000562_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000905_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000580_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000806_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000852_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000665_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000327_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000149_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000824_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000975_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001075_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001051_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000669_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000150_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000650_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000734_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000237_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000420_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000726_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000293_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000059_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000175_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000497_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000275_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000028_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000424_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000137_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000979_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000772_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000785_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000210_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000209_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000550_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000299_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000315_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000509_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000961_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001037_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000346_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000844_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000944_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000940_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000828_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000002_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000642_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000920_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000244_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000560_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000955_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000856_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000396_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000632_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000800_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000452_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000218_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000345_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000067_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001059_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000873_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001070_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000197_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000342_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000179_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000446_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000243_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000719_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000037_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000072_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000711_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000797_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000006_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000690_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000483_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000110_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000524_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000221_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000995_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000992_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000454_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000760_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001096_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000962_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000996_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000543_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000821_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000595_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000131_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001083_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000492_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000274_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000872_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000667_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000251_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000815_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000390_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001039_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001033_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000520_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000661_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000259_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000144_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000270_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000192_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000811_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000720_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000289_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000281_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000491_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000783_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000288_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000537_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000729_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000638_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001095_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001078_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000358_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000816_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000201_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000200_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000793_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001002_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000374_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000636_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000874_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001019_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000058_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000226_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000809_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000214_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000121_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000011_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000547_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000046_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000561_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000126_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000045_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000566_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000202_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000932_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000659_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000938_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000320_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001042_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000671_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001020_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000393_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001041_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000655_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000258_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000801_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000426_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000475_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000207_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000666_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000450_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001073_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000054_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000155_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000057_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000249_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000190_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000635_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000033_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000770_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000472_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001046_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000886_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000136_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000458_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000727_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000795_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000870_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000477_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000147_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000215_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000073_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000333_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000533_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000180_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000796_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001018_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001086_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000321_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000082_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000429_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000363_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000034_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000947_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000545_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000343_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000487_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000980_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000065_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000286_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000462_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001007_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000391_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000789_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000653_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000280_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000884_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000361_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000199_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000085_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000466_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000895_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000903_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000050_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001009_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000470_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000652_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000241_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000303_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000501_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000375_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000212_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000247_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000272_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000220_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000070_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000628_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000914_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000401_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000953_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000569_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001044_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000765_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000648_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000565_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000744_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000211_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001074_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001053_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000165_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000040_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000442_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000960_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000138_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000255_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000585_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000542_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000183_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000507_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000380_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000799_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000917_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000012_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000576_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001060_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000480_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000254_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000660_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000125_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000567_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000946_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001036_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000094_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000988_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000633_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000900_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000331_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000732_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000124_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000579_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000687_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000616_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000784_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000474_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000845_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000592_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000529_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000654_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000119_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000476_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000317_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000020_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001091_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000384_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000387_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000203_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000919_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000276_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000807_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000456_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000107_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000951_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000950_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000228_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000623_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000399_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000973_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000151_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000122_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000741_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000692_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000376_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000915_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000930_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000104_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000298_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000295_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000355_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000615_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000118_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000222_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000330_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000738_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000422_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000625_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000641_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000637_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001056_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000758_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000508_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000089_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000181_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000287_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000683_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000128_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000005_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000675_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000593_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000664_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000494_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000461_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000253_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000326_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000712_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000728_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000372_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000114_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000600_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000700_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001004_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000341_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000078_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000017_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000318_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000283_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000023_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000189_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000532_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000347_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000677_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001057_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000432_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000083_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000041_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000764_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000911_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000386_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000449_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000522_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000493_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000564_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000016_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000583_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000499_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000505_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000366_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000248_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000176_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000148_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000063_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000813_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000263_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000402_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000656_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000838_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000025_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000901_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000803_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001079_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000152_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000514_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000611_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000266_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000257_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001076_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000536_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000245_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000869_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000418_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000688_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000954_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000574_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000460_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000233_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000925_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000791_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000354_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000139_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001089_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000909_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000027_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000164_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001071_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000586_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000075_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000224_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000022_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000921_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000749_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000080_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000904_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001011_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000877_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000068_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000324_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000525_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000445_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000707_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000864_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000109_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000912_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000634_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000021_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000102_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000991_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000971_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000367_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000360_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001054_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000839_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000417_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000763_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000162_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000939_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000468_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000558_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000721_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000019_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000782_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000761_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000922_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001072_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000631_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000578_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000857_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000535_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000115_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000584_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000604_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000827_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000061_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000423_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000332_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000311_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000469_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000352_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000934_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001050_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000515_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000368_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000120_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000842_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000630_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000188_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000291_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000805_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000464_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000906_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000042_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000778_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001069_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000774_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000757_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001045_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001047_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000713_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000216_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000999_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000581_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000587_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001085_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000227_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000945_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000381_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000496_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000964_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000081_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000310_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001001_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000231_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000910_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000888_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000278_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000605_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000837_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000970_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000163_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000170_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001014_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000924_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000544_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000217_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000978_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000177_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000471_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001058_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000157_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000997_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000897_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000026_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000305_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000219_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000407_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000794_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000780_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000076_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000261_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001025_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000009_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000447_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000724_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000112_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000773_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001006_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000686_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000788_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000388_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000349_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000618_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001066_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000699_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000279_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000834_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000053_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000621_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000172_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000091_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000556_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000843_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000223_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000693_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000246_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000265_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000395_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000670_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000473_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000926_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000481_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000523_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000436_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000629_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000572_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000927_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000290_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000626_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000498_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000056_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000455_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000504_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000893_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000682_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000972_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000739_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000798_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000814_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000891_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000737_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000766_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000817_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000178_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000640_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000459_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000329_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000048_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000187_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000113_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000117_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000099_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001062_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000277_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000134_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000916_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000965_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000530_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000695_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000553_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000087_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000106_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000620_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000364_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000716_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000876_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000937_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000105_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000394_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001065_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000853_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000548_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000412_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000055_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001080_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001077_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000714_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000510_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000337_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000527_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000206_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000485_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000229_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000704_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000143_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000385_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000829_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000096_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000710_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000490_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000010_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000684_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000590_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000103_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000591_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000285_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000575_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000335_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000323_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000173_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000338_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000976_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001063_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000062_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000440_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000754_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001093_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001097_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000512_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000282_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000098_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000753_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000518_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000482_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000658_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000024_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000408_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000489_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000382_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000004_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000551_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000169_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000488_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000294_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000679_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000336_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000415_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000403_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001055_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000835_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001003_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000552_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000503_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000750_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000747_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000717_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000108_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000370_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000052_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000001_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000880_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000093_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000427_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000748_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000095_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000825_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000861_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000013_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000007_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000804_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000725_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000889_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000213_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000851_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000292_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000879_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000740_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000236_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000709_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001035_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000127_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000302_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000043_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000154_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000943_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000573_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000607_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000993_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000833_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000185_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000166_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000234_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000322_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000673_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000191_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000359_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000668_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000271_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000957_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000918_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000090_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000204_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000193_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000984_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000981_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001028_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000240_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000135_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000755_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000694_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001031_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000554_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000397_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000624_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000769_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001021_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000088_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000030_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000334_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000365_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000145_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000854_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000284_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000968_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000348_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000847_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000111_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000405_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000987_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000849_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000273_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000142_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001008_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000077_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000969_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000502_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001034_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000948_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000818_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000899_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000646_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000479_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000680_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000441_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001061_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000672_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000998_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000848_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000014_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000907_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000528_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000830_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000777_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000433_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000526_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001013_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000196_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000133_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000958_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000913_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000049_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000868_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000443_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000406_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000862_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000437_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000444_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000430_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000691_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000596_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000956_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000047_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000153_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000531_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000582_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000823_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000589_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000158_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000008_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001094_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000071_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000983_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000409_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000252_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000256_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000511_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000735_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000963_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000500_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000974_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000902_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000168_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000250_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000439_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000731_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000044_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001082_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000029_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001038_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000123_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001023_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000577_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000308_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000819_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000066_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000003_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000967_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000486_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000069_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000307_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000649_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001092_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000746_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000457_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000705_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000146_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001032_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000986_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001005_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000832_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000896_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000826_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000639_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000356_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000597_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000410_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000622_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000702_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000101_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000841_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000513_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000867_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000885_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000371_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001027_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000928_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000448_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000689_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000186_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000929_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000571_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000079_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000416_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000451_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001087_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000015_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000657_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001049_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000160_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000645_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000300_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000603_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000419_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000762_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000379_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000086_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000810_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000378_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000400_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000130_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000546_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000414_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001081_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000260_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000036_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000035_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000866_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000309_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000952_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000994_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000599_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000369_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000377_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000606_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001000_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000235_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000404_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000859_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000467_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000411_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000882_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000559_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000601_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000463_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000383_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000389_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000141_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000742_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000230_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000238_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000313_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/001026_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000171_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000549_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000064_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000242_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000129_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/01/000892_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001116_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000681_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002512_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000936_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003965_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002769_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000018_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004332_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000644_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001677_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000759_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001234_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003595_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001824_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004311_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002754_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004041_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000506_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002389_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003619_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001099_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003088_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003791_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001859_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000428_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002731_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000140_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001964_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003490_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004369_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002128_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004283_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001744_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000836_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001584_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002944_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003407_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001362_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003837_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003852_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002647_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001067_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000198_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002568_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004511_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004340_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003721_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002724_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002661_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001783_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001681_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000208_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000540_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002715_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001411_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000619_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002835_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000941_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001254_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004090_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000038_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001899_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002813_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002951_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000084_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003630_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003332_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002582_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000413_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002991_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002416_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004505_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003898_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000031_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001792_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003449_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004165_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000353_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001306_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001760_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000674_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004529_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003607_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003242_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000340_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002403_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000538_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003930_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000304_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002547_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003541_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002590_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004218_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002278_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001731_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000846_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000267_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003278_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000541_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002343_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001239_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000685_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001854_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001016_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000676_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000339_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000786_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001370_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003613_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002323_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004237_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004241_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001451_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000651_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002016_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000982_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001178_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001454_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003782_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001179_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003622_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003705_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003610_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003813_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004096_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002398_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003989_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001373_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002785_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001352_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003190_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004417_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003087_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000232_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001799_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001716_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000421_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003271_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001885_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000357_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003216_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003039_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002927_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003798_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003160_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004000_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003921_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003015_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000989_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001598_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003356_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002627_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001223_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002499_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003473_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001228_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000768_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002574_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002133_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001691_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004419_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000156_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001586_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000060_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002819_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002387_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001048_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001183_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004267_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003424_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000074_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003980_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001043_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001825_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004350_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003680_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001424_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003191_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000453_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002907_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001200_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001012_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003239_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001456_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000521_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002517_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004383_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001633_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003472_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003944_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003245_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001319_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002613_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001776_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002749_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001489_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000840_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003396_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002370_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000977_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003975_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001894_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004214_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004094_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001090_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003627_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000495_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003126_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001366_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003646_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000344_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003848_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004005_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003752_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000519_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001664_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003602_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004331_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001694_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003260_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002700_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001450_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002912_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004122_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003543_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001144_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001029_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003467_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000182_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004207_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004298_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001304_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003629_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002902_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002131_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003946_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001774_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000718_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004073_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001505_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000296_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001713_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000465_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003107_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002588_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001614_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000568_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000268_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003065_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001449_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001989_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000850_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002351_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001365_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002852_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001631_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004366_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003288_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003724_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002658_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002257_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003864_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004034_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001292_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001940_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002029_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000557_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002422_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002840_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004044_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004192_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003446_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001180_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002622_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003367_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001429_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002664_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001888_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000431_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001010_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002179_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000425_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000820_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001593_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004307_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001426_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004441_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003922_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000539_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001548_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000643_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001294_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004348_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000588_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002771_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001778_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000617_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001685_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003323_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004421_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003872_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000949_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002644_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001401_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001509_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001844_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000771_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001052_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001589_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003658_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003814_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001162_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001233_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003555_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000610_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003265_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003952_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003022_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001289_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004460_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000723_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001552_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002854_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000722_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003836_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002973_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000478_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001068_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002932_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002379_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004061_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000435_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002242_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003984_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001367_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002444_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000438_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003270_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003211_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001943_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002996_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003915_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000696_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000328_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001274_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000627_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001663_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001912_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002417_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004113_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003556_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002470_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004278_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002777_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002428_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002300_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002942_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001329_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002674_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000602_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004535_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000756_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003886_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004059_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003892_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001106_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001405_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001168_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001504_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002763_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000097_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001817_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004082_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001129_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003092_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000614_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000039_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000562_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000905_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002154_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003292_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003101_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004469_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000580_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001317_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000806_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001623_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003132_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002210_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002316_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001719_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002748_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001928_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002895_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004309_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000852_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000665_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003909_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000327_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004445_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000149_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002093_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000824_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003251_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004056_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002246_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000975_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003538_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001247_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001075_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001051_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000669_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001124_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001609_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002432_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000150_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001855_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002061_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000650_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000734_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003902_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001789_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002183_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002490_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002863_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000237_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000420_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003117_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001726_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001143_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001280_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003315_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003832_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000726_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003895_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001423_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000293_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000059_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001972_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002734_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000175_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004452_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001739_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003685_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000497_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000275_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000028_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002844_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001849_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000424_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002983_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001140_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003127_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000137_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002729_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001232_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003319_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000979_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002940_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000772_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000785_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001250_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001711_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001655_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004519_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004337_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003165_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002092_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002381_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001210_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003299_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002623_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000210_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001394_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003582_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003974_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001512_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000209_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000550_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003713_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002593_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002877_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002158_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000662_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001956_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000299_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002132_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001994_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001284_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001275_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000315_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004416_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001759_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000509_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004220_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000961_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001037_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002396_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000346_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004105_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003188_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000844_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001814_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002261_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000132_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003609_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002026_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001305_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000944_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003841_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000484_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003628_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002640_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000940_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000002_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004012_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002192_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000642_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002483_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003571_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000920_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003935_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000244_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000560_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003272_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003918_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003131_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000955_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004323_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004400_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002364_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002500_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004125_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004045_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003950_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004358_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003057_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000856_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000396_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003037_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003329_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003566_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001761_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003755_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000632_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004084_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003631_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004172_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003100_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004169_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003280_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004198_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000800_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000452_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004427_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000218_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003355_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002686_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003522_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002287_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003002_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001624_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001212_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003810_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002599_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004065_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002305_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001225_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000345_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001296_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002986_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000067_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002004_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001059_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000873_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003093_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002106_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002199_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003606_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004429_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002560_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004344_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002328_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001070_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001513_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000197_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000342_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002443_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000179_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004341_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001990_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003860_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000446_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000243_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003483_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002078_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002938_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004088_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003560_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003345_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000719_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004507_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002668_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004392_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002960_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000037_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003572_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004138_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000711_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000797_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002605_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002082_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000006_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000517_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000609_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000690_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003447_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003430_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000483_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000110_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002736_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003712_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001526_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001834_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003569_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004003_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002096_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002871_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002874_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003374_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002697_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000524_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001413_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003297_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003740_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003313_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002049_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002982_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002540_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004147_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001334_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003348_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001581_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002188_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000221_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001393_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001235_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003137_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002375_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002839_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003759_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003620_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004315_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004418_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000995_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003207_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002272_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002473_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002570_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001536_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003558_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002237_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003054_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003825_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001881_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000992_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004190_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001534_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000454_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001428_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000760_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000032_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003391_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001196_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003310_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002831_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003804_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004457_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003650_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001096_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003223_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001303_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003551_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000962_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001169_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000996_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001597_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004536_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001342_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000543_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003581_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003234_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002091_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001361_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003596_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000362_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003268_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003967_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000821_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004409_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002886_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002277_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000595_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002450_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000131_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001083_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002139_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003061_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000492_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002196_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002601_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002150_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004137_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003029_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004203_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001871_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002882_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003905_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000274_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001975_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003982_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000872_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002010_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003987_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000667_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000251_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003164_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000815_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000390_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001039_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004221_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001033_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003730_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003025_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000520_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002177_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001128_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002313_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004055_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001936_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003526_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000259_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001689_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003475_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002303_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003085_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003400_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000144_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001503_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000270_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003311_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004534_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002663_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002621_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004254_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002906_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001419_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001679_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002354_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004305_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004304_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002775_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000811_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000720_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003361_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000289_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003772_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000281_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003947_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004336_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003954_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002350_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000491_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001320_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001973_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001113_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002800_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000783_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002308_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000288_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004438_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003510_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004091_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002315_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003276_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004463_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001931_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001483_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001471_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003800_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001561_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002666_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004286_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003778_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003230_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003677_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002098_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001126_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002947_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004436_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002722_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000729_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003906_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003866_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004377_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003696_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003717_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003574_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000638_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001095_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004451_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004260_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001840_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003116_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001750_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001078_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004466_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003805_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000358_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000816_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003599_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004449_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000201_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000200_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002037_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003372_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003264_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001740_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003018_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001987_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002107_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000793_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003001_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001660_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002437_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002719_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003681_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000374_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001347_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002041_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000636_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001353_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003366_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001889_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001127_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002858_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004472_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003122_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001775_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002739_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002948_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000874_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003668_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004027_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004387_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002645_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001338_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003020_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002253_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001626_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001019_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003206_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003182_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000058_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004224_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002019_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000226_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004236_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003830_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000809_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000214_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002215_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003231_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002872_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004189_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003275_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000121_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004123_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002178_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001120_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000547_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002294_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002317_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001798_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003920_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003845_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004330_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002541_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001487_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000046_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002846_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001745_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002509_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003184_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004222_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000126_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003671_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000045_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004501_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001267_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001636_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002974_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001359_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001895_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001315_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002423_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000932_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003753_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000938_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001804_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003553_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000320_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002632_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003007_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003647_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003771_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002782_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001042_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000671_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001291_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003402_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001645_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001748_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004274_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002027_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001251_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001909_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003302_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004108_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003335_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001041_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003662_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001639_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002324_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003890_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004246_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000655_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001308_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000258_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000801_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000426_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001948_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002860_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003162_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001755_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004092_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003623_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002920_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000207_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001566_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002384_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000666_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003210_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002474_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000450_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003821_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003393_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001073_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003257_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000054_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004296_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001947_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001084_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003444_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000155_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004404_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003344_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002429_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003187_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000249_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002143_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002134_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003389_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001345_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003496_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000190_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001336_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000635_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003408_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001734_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002071_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000033_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003350_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003385_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000770_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001988_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002795_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002529_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003817_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002050_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002611_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002307_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000472_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001046_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003783_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003327_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000886_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001324_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001573_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000314_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002943_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004488_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003130_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000136_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002283_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000458_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003966_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004531_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002586_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002528_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000727_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002646_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002710_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001717_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002708_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000795_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002200_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001519_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002368_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002486_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001446_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000870_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000477_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001252_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003173_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000147_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000215_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000116_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003392_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003986_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003030_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003200_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000073_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001922_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003649_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001437_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002280_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001911_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003548_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002138_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000333_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000533_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001246_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000180_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004282_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003004_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002816_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003575_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002204_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003174_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001541_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004276_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001350_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003486_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001667_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000796_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002410_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001018_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002505_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002553_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001086_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002216_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002597_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003213_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004216_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003017_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001580_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001875_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001357_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000321_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002968_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000082_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000429_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003750_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001523_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001642_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002577_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001530_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000363_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002556_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003529_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003702_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002175_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003511_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001151_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000545_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000343_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001242_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000487_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001341_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000980_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003557_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002048_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002085_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001722_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000767_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003576_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004074_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000065_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000286_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003041_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001905_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002587_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003450_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002171_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003891_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003518_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003343_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002369_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002451_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000462_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001007_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002240_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001469_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000391_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004333_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002035_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002802_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001259_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004051_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002650_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001088_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003035_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000789_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000653_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000598_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000280_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003277_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003660_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003815_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002399_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000884_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000361_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000199_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000085_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004520_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004378_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002619_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002301_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000466_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000895_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003150_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001431_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002620_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001874_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002740_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002058_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004018_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004504_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002796_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002807_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000903_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000050_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001951_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002534_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001282_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001188_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001421_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003229_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002978_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004509_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001009_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001494_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004357_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002857_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002346_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000787_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000051_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002680_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003937_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000652_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003170_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001601_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002109_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000733_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000241_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001625_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000303_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003689_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003621_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003769_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001592_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001610_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002649_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002374_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000501_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001968_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004373_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000790_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001676_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003611_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000375_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001396_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000212_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000247_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001538_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002928_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003856_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003194_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004161_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002333_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003773_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002412_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002721_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003779_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003469_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004205_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002567_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001577_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002247_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002358_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000272_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003301_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001256_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001547_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003981_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001546_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002803_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000220_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003305_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003857_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001149_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003263_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001991_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004002_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001470_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004160_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000812_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001941_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004343_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004376_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003888_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004079_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002327_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004325_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002624_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001980_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002787_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001596_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001408_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003849_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000070_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000628_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002892_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001678_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002845_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002733_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002197_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002580_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001833_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002330_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003876_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003349_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002097_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002176_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000914_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002488_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002465_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003425_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001863_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002503_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001996_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002054_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001653_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000953_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000569_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004465_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003690_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002921_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002271_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001756_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002250_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002631_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001299_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001015_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001343_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001374_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003757_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002985_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004062_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001044_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001556_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000765_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000225_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001995_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000648_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000565_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004025_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000744_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001277_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003624_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003855_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003861_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000211_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000985_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002418_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004476_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002202_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003441_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001466_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002291_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003232_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002999_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002656_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003104_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004247_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004285_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001074_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004259_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004496_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002441_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001053_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000165_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002255_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002000_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003406_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002421_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002786_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003159_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001651_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002063_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003801_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000040_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003169_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000442_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003593_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003333_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002220_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001710_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002213_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004269_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001773_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003670_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003249_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000960_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003434_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003019_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001835_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002385_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002717_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002992_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003971_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003695_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002025_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001528_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003665_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004411_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003744_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001933_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002923_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002798_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003119_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000138_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004454_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001787_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004313_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000255_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001440_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001827_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000585_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000542_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003504_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000183_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002382_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001326_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003360_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004212_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000507_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002735_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000380_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004316_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002557_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004516_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000799_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001766_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000917_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001915_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004239_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004087_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004473_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000012_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000576_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003811_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002543_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001060_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003583_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004301_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003519_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001923_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001784_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000480_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000254_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004017_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003336_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003070_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000660_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001376_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001644_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002056_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003600_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003196_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002245_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003828_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002751_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000125_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001189_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000567_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000092_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001585_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002234_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000946_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001141_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001036_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002770_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002937_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001482_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000608_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004448_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004076_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000094_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001758_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003320_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000988_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003514_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001704_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003129_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001524_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000900_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001268_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001753_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000331_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000732_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004272_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001270_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002824_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003998_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001955_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001979_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000124_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001314_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002232_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003220_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001310_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001961_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000579_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002521_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002546_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000687_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002241_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003163_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002111_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004322_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002180_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001258_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003754_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001495_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000616_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001721_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004470_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002794_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002044_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003428_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002086_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003081_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002113_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002116_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003398_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003820_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001666_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000875_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002984_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001522_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002259_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001417_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001568_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000784_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001244_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000474_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000845_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003900_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004527_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000592_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002703_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004339_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001628_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002694_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003440_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002832_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002510_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000529_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004426_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000654_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004068_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000119_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000476_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002853_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000317_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001974_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002067_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001877_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001657_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002581_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003636_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001718_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001165_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004219_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000020_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003331_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003578_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001091_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001245_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001807_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004359_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004178_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003078_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002608_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001635_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003889_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002682_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000387_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001950_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002239_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002690_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001372_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002712_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001481_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001902_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003679_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004028_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003964_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003495_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003386_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000919_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000276_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000807_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000456_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001255_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003326_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003634_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002094_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002312_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002489_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003827_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001815_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002814_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004458_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004432_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001298_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001222_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001409_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001323_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000776_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000107_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001412_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003134_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001351_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000951_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000950_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003644_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003180_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002760_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002281_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002045_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001473_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000228_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001897_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003439_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003761_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000399_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003413_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004029_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000973_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000151_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004410_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003719_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003716_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003098_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000122_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000741_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004196_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003603_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003435_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000692_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000376_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003643_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003788_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004104_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001441_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004292_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000915_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003183_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000930_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004250_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004447_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001659_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003354_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004374_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002699_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001485_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002681_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001499_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001104_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002533_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000104_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000298_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003316_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004515_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002036_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003797_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000295_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003498_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000355_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003373_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002821_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001963_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001939_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004253_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002062_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001167_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000615_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000118_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001457_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002970_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002741_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001098_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002898_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003474_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003056_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004471_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001749_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000222_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003325_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002687_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001480_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004083_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002651_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001286_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001916_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004291_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004494_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001816_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001613_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003011_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000942_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001850_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002121_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003097_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004128_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000330_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003487_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000422_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001896_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002933_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004467_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002671_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000802_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002228_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002837_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000641_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002949_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004217_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002702_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002752_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000637_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001172_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001056_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000758_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000508_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001328_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002565_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003205_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000089_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002174_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000181_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002304_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002945_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002391_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003059_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001527_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002076_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001648_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000287_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003158_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002230_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003953_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004223_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001390_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004244_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002461_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002994_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001730_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001735_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000683_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000128_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003128_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001158_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002676_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000675_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003105_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003013_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002896_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004280_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002373_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000593_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001105_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003554_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001525_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002918_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003829_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002292_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000664_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002759_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001472_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002607_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001866_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000494_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004319_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004489_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003241_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001226_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004136_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003808_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003540_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000461_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004408_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002685_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004043_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003308_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004306_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001772_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003171_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000253_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000326_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002362_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003124_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002466_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001257_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000712_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002208_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000728_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003728_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002916_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001638_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003573_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001674_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000372_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000114_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002039_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001696_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002867_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002401_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001904_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000935_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002344_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002243_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001637_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004141_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001729_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002195_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002377_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000600_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004110_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001810_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001488_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000700_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001535_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001004_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003419_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003339_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000341_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002127_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001194_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003726_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001865_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003996_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003352_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002566_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000017_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003729_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003697_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002689_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003653_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004277_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001837_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002217_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000318_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001649_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001311_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001551_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001202_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002595_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004440_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000283_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004265_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001364_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000023_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004228_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003589_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003043_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002778_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002077_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000189_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004013_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002919_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003591_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001654_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001927_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001578_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002626_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001829_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003259_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002160_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003688_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002137_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002688_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000532_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003226_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001192_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000347_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003563_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002309_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003423_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002021_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002554_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002173_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003870_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003195_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001926_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003923_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000677_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004171_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001057_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001136_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001153_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001243_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000432_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002855_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000083_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002295_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000781_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002925_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004402_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000041_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002648_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000764_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003499_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001670_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002883_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000911_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001507_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001204_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002299_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001715_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002211_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000386_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000449_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000522_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001100_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000493_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000923_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002151_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002967_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004414_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002236_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003470_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000564_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000583_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003437_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001848_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000205_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000499_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001605_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003199_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003052_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002506_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002876_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000505_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002414_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004235_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002168_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000366_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002990_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002870_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001832_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002784_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002934_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000176_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001627_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002395_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002799_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002053_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004146_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002677_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002518_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002737_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003064_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002725_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002730_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004478_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003897_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000148_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004290_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002922_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003461_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002269_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003248_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000263_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002600_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003983_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003047_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003807_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001501_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000402_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003114_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003931_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002101_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003286_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004072_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002404_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002081_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002038_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003409_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004046_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003785_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003746_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003775_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001590_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001862_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003282_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003672_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002683_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000656_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002290_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000025_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001882_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001201_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001836_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004538_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000901_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002311_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000803_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001079_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002746_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003321_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003766_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001497_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001600_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000152_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003806_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001517_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004159_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002136_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003824_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003725_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000514_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004099_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002286_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003632_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002498_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004314_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000908_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001786_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002550_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001858_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003136_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001355_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002051_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002115_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004166_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000266_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001688_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000257_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003418_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000933_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002678_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001686_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002791_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003459_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004342_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001709_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002264_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004162_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002561_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003819_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004116_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003765_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003415_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001867_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000245_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000869_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001986_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000418_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001240_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000688_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002405_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003747_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003154_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000954_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000706_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004174_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002345_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000174_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002905_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000574_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000460_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002780_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002252_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000233_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003338_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001467_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000925_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000791_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004475_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002157_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001461_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000354_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000139_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003963_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003675_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001161_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004299_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004225_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002033_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004328_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001110_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003036_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001184_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004539_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003745_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001402_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000909_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003703_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002223_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001901_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000027_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000164_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001071_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002672_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003997_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000586_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004464_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000075_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002738_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001706_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003246_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002279_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000224_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004446_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004004_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003484_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001703_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003936_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004479_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004396_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001123_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001491_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003693_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004215_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003016_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002997_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002657_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002836_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001564_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002792_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002055_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000022_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002911_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000921_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001793_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002958_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003141_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000749_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000080_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000904_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001751_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000184_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002186_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001011_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000877_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002709_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002514_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002720_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004480_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001309_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003762_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002781_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002635_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000068_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000324_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004040_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003597_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001518_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002879_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001809_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004388_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002478_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002753_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000707_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001170_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003884_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004229_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000864_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001822_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000109_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004070_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001553_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000912_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002034_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000634_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003318_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001791_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001629_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000021_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003661_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000102_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003515_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000991_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004101_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000971_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004422_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000367_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001474_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000360_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004226_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001558_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001054_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000839_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000417_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003707_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003111_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001145_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001687_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002248_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003973_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001723_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002612_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001932_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003240_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001017_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003436_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003539_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003108_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004175_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001714_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003080_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000162_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003912_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000939_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001555_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000468_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003033_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000865_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002218_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001135_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000558_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002817_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002768_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000721_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002156_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003244_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001906_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000792_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001265_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000019_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004112_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001886_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004206_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003789_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000782_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002767_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000195_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003651_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001992_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003502_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000761_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000922_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001072_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002189_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000631_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001752_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000578_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002850_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000857_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004349_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000535_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000115_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003218_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004154_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004406_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003544_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001337_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003083_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000584_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002728_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000604_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002130_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001312_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003663_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001339_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003172_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003198_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003225_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002348_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004281_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004049_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000061_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000423_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000332_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004525_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003962_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000311_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001109_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004271_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000469_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003908_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004380_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001942_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000352_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000934_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003135_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002229_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002501_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004288_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002809_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002532_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002965_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003417_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002129_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001050_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002995_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004232_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003224_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000515_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002897_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003958_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003067_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003269_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001616_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004186_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000368_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002761_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001138_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000842_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003283_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002167_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002956_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000630_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003990_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004047_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000188_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000194_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002847_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003699_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003527_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002326_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003667_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000291_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001164_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001570_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000805_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000464_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002089_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001211_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002357_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001476_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001330_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002880_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004334_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000906_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000042_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000778_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002513_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001069_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002515_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001190_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003655_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000774_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002913_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000757_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002491_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001045_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001047_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003674_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001453_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003317_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000713_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001813_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001157_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002023_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000216_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003221_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003378_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003285_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003247_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003149_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003448_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004423_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001213_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001993_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004197_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002522_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002950_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003928_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003786_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003082_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001764_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003243_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001498_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002355_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003880_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004107_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004093_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000587_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001981_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002144_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001295_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003289_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001085_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000227_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000945_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002564_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003466_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003708_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001262_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003479_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000496_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004393_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002339_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003010_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001983_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002549_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000964_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001656_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001803_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000081_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003306_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004008_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001668_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002930_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002319_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000310_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001001_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003799_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004433_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002665_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003822_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004199_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000231_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000910_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001064_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002148_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002765_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003412_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000888_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004118_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001209_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002163_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000278_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000605_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003236_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001371_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003868_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004251_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003084_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000837_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001796_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003780_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001331_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000970_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003567_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002042_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000163_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001957_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004066_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001662_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001599_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001452_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003924_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001575_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003383_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001823_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001493_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002757_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000170_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003796_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002340_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001014_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001146_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001433_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000924_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003748_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000544_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001185_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003985_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003252_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003535_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004297_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003388_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000217_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003178_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004129_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001484_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002413_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000978_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000177_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002455_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000471_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002926_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003377_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001114_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001812_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003143_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001058_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000157_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003481_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002394_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002980_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001934_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004163_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004148_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001516_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000997_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001468_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002321_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001856_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003328_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000897_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001102_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003948_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004484_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004512_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001148_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003901_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001925_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003005_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002342_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001381_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000026_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003733_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003404_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000305_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002018_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002714_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000219_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004407_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003069_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000407_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003168_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004537_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000780_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002507_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002347_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001260_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003929_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003215_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002779_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001770_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000076_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001506_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001767_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002187_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003153_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003883_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002122_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003026_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000261_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001025_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002889_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001728_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000009_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003732_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003261_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003148_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002762_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002256_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000447_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001166_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000112_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004173_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002052_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001549_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002987_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000773_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002480_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002254_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003337_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003960_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001699_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003403_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003071_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001403_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002673_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004352_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001006_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002615_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003635_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001917_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000594_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003659_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001115_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000686_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001802_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003654_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001159_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001221_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000788_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000388_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004181_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002141_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004210_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004293_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000349_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004320_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001066_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000161_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004242_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003201_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001583_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001658_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002634_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003410_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000279_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001316_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002090_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002388_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003066_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002618_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000834_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003687_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003508_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004035_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003492_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002123_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000053_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004153_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003617_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004401_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000621_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002064_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000172_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000091_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000556_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003991_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002790_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001819_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004080_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002170_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000843_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000223_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002012_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003826_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000693_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004023_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002822_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001604_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000246_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003564_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002569_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002103_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003300_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001392_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002267_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003698_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003382_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003401_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002941_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002524_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001945_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003684_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004302_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001742_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002009_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001443_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000395_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000670_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002427_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002110_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002214_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002559_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004262_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002578_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003456_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000473_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004443_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002707_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004450_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002201_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001984_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000926_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003520_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002783_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004151_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003309_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000481_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000523_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003113_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002864_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003021_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002325_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000436_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003859_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000629_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003598_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000927_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003969_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001266_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003994_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001788_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000290_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001630_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003189_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003669_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004233_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000626_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001293_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000056_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000455_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002584_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004057_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003999_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002068_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001272_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003480_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002165_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003528_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001490_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000504_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003513_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002411_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003723_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002472_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002602_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002806_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003605_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002955_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001900_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004015_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001380_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001460_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000893_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001890_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000682_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004310_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003910_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000966_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000972_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002652_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003616_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002442_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000739_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000798_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002184_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000814_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003683_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002464_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003281_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001479_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000891_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004213_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000737_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003144_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002361_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002861_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001712_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002952_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002592_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003115_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004255_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000766_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002161_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000817_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002670_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000808_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000178_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002376_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003792_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000640_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003219_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003842_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003838_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003445_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003604_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003942_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003294_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003494_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003155_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003739_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004038_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000459_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000329_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004394_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002732_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000167_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001843_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002856_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001918_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003542_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000048_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000187_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003977_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003340_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004030_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001156_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001543_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003549_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000113_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003995_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003346_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000117_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003875_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002776_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001249_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004270_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004481_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002571_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002610_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000099_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001062_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003342_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002469_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001496_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000277_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003862_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002878_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000134_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000916_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001800_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003993_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002031_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003390_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001565_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002119_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000965_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003193_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001959_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000751_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004264_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004184_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001217_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003032_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002406_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001883_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000530_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001684_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003429_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004462_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002793_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001671_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001953_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000695_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000553_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003645_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003330_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001682_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004486_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001445_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001640_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001253_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002099_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002881_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002563_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004385_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000563_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003089_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002706_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003262_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002808_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002393_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002969_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002149_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003714_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003477_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000106_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001935_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001486_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003893_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003955_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000620_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002022_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002060_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003865_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001220_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000364_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001346_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000716_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004498_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000269_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000937_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002718_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003255_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004144_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002979_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002235_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001150_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000394_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001065_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000853_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002258_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003204_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000548_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003217_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002365_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000412_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002409_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002400_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003648_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002190_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001438_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001887_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000055_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002797_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001322_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002548_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001080_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001077_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001375_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002231_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002716_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002914_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002147_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003618_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003431_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000714_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002341_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002606_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000510_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001273_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001878_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004424_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004131_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003904_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004100_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002433_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004142_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002572_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002153_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002238_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004187_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002910_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002032_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001607_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001707_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004075_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000337_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000527_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000206_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004102_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000485_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002270_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001998_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004257_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004077_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004514_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004037_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000663_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001698_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000229_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002335_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004495_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004031_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002142_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002088_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004521_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003550_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001763_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001455_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000704_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000143_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003045_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000350_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001379_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002684_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001879_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002017_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002459_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003267_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004155_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002774_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001920_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001910_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002145_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004487_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001695_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002764_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002851_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001215_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002435_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003787_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002825_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000829_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001864_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002420_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001173_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000096_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000736_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003678_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003590_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000710_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001569_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002273_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003375_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001622_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003874_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003197_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000490_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002917_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001024_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001872_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004346_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002654_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001112_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000010_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002419_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001207_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004435_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000730_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001125_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002637_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003741_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001327_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003038_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002758_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000590_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003633_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000103_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001727_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002696_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003208_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001177_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002901_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003460_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003145_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004303_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001921_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004103_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003416_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000591_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000285_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000575_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000159_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004152_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003777_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003525_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004149_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000323_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000173_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003917_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001459_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003312_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003250_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001163_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003715_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001946_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000570_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003858_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004372_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003577_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000338_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000976_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002233_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001725_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004245_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004266_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001063_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002244_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001174_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003570_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002862_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002962_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000062_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001673_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001768_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002679_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003760_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002069_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001870_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000440_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000754_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004177_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002829_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003524_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002596_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004317_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001475_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001093_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000898_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002745_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001978_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003919_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003735_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004420_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001238_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002742_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001559_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001595_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003899_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000392_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001097_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003027_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001806_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003781_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000512_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002833_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004024_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001830_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003161_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003637_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003177_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002691_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000282_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002431_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002083_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003894_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004019_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003363_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004200_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002552_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003887_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004022_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001907_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000098_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003421_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003290_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004474_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001436_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003534_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000753_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002963_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000518_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002024_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003970_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003768_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001582_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003451_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000482_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000990_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000658_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001606_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002698_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003523_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000024_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003046_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001313_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002203_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001348_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004354_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001278_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004258_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002194_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000100_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000743_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000408_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002589_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002426_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002274_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003903_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003704_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004201_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003546_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001785_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002843_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002629_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001838_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001693_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003770_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002266_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002936_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003362_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001970_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004413_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001414_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001661_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003588_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004145_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000612_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000489_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004050_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003076_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002182_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000382_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004039_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000004_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000398_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001458_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001572_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002562_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001880_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004345_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003709_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002087_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003851_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004060_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002439_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001669_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000169_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001944_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002642_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000488_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002002_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004086_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002003_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004428_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001206_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001617_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004098_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003652_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004156_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002152_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003586_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002329_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001608_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003157_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002603_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000294_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000679_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001344_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004391_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000336_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003545_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002551_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001567_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002579_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003489_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003913_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000403_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000775_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001055_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002805_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000835_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001003_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001898_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002628_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000752_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000552_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001732_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001287_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000750_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002359_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000747_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002695_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004384_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001218_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000717_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002336_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004117_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004275_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002931_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000306_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002755_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002028_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002747_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004180_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000108_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001913_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003959_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001892_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000678_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002772_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003957_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000052_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004528_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003073_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000001_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000880_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000093_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000427_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004300_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001811_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000748_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000095_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002251_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001439_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003756_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001444_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002043_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003763_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002638_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002727_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000825_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004503_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001236_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004134_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003209_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003258_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002536_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003284_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004412_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003186_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002383_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002660_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003742_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001746_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002449_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004261_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002284_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004132_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000297_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002523_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003925_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003532_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003222_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004170_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002095_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002390_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001782_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000861_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000013_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001754_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001891_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000007_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003802_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000703_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001967_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000804_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004405_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002289_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002961_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000779_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000725_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000889_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001966_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000213_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003579_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004014_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003028_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002074_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001861_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003380_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003314_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002485_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000851_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003521_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001227_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003075_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000879_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002402_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001665_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001462_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003399_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002397_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000740_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002756_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003873_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002975_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000239_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001283_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003414_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001779_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002047_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000236_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000709_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001035_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000127_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001368_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001463_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002372_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002866_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003718_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002013_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003506_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002989_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003945_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002964_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001643_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002849_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000302_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001197_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004273_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000043_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004370_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002084_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001820_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004318_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002227_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004121_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002008_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003776_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001781_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000154_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002625_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002957_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000831_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003304_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004211_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004001_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003090_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004499_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003468_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004533_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004006_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002015_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004085_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004183_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000573_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004415_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004238_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001111_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001652_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000607_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003738_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004526_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000993_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002904_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000833_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003433_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003458_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002971_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004390_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000185_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002711_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002481_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002262_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003790_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002583_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001930_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000166_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001529_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000234_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002801_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001841_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003927_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003351_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003471_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000322_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000673_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001997_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004375_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002146_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003850_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000668_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004115_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003877_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003615_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003988_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000271_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001914_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002636_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000957_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003907_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004042_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000918_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002198_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003379_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003482_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003978_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001985_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002040_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004403_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002828_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004204_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000204_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001618_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002320_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003911_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001378_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004195_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001587_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001384_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000193_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004133_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002265_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003099_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000264_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002788_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004351_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003307_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000984_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002639_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000434_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001705_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002585_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000981_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001147_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001028_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000240_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002544_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002525_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003364_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001464_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002371_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003133_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001139_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001826_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002117_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000135_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000755_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000694_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002669_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001542_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001031_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002070_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001738_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000554_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003517_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003138_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000397_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004485_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003235_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002693_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000624_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004164_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000769_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004522_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001397_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004109_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002701_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003968_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000088_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000030_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000613_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003694_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001680_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002102_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002868_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003641_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000863_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004089_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000334_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002314_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001965_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003181_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000365_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000145_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001690_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003096_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000745_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000854_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001790_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002434_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001929_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002456_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001873_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002511_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003940_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002558_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000284_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002249_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002318_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003640_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001588_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000968_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001632_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002079_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004139_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000348_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002946_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003625_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001954_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004431_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000111_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000405_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002140_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000987_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003432_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003795_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003601_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000849_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001647_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003536_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000273_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003972_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002337_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001508_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002643_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004202_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000142_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003465_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001797_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001008_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002460_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003612_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003266_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000077_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000969_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003846_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003295_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004386_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002446_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003179_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000502_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002818_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001034_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002823_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000948_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004395_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003146_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001410_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002535_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004009_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002494_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001354_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002766_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000860_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002988_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002530_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000818_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001884_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003992_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002298_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003559_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000899_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003594_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000646_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000479_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000680_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003562_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002810_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002066_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003095_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002576_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000441_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004442_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002873_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002598_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001369_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003823_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001061_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000672_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000848_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003691_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001828_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003296_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003112_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000014_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002001_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000881_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000907_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000528_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000830_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002842_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004067_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001208_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001771_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004368_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000555_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002360_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002467_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000777_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003202_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000433_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000526_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003961_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001101_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003731_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004371_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001154_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004324_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004327_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002604_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000196_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000133_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000958_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004430_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003547_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001603_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001831_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001801_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002804_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002108_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002169_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003291_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001152_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001155_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000913_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001388_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001399_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003322_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001780_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004026_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003561_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004294_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001876_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000868_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001383_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001540_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000443_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001301_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003058_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004338_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003530_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000406_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000862_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001860_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000437_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002812_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000444_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003397_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000430_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003394_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002020_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000691_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001478_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004461_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001465_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000708_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003491_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001285_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002848_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000596_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002492_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004329_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003024_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001521_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004081_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002331_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002080_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003053_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003102_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002609_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000956_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002105_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002743_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000047_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000153_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001757_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000531_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003368_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004530_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004493_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003585_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002222_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001230_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002072_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001160_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003734_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001133_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002502_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003068_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004150_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004063_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000823_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004016_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002692_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003812_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003042_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003751_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002104_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003214_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000589_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003273_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001908_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003949_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000158_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001022_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001976_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003003_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002869_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000008_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003700_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001094_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004193_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003365_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004188_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001545_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004167_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004268_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003673_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004459_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001672_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000071_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001448_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000983_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000409_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003664_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001332_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001594_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002288_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001937_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004399_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002030_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003758_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001199_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003072_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002205_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000252_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003934_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001203_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003976_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001356_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003453_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000256_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000511_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002453_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002448_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003156_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000963_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001777_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000500_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003493_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002827_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001903_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002112_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000974_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003956_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003943_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001107_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003656_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004010_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000902_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002282_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004011_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000168_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000250_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003784_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003103_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002191_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003454_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002006_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004518_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003405_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003568_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004482_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001325_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003863_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001132_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002662_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000731_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000044_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001082_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003896_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004524_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002516_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001531_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003227_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003743_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001510_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000029_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001038_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000123_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001363_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002057_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004158_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001023_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000577_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004287_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003979_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003062_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001318_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001263_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003854_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001579_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003293_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003608_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003341_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000819_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003835_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003175_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004437_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000066_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002005_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003503_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004127_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000967_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001700_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002065_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000890_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001520_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003843_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004455_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004353_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003885_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000069_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000351_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000307_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004106_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000649_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001092_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002614_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000457_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002352_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000146_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002440_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003000_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001032_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003809_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004194_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004513_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004071_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002415_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002159_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003212_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000986_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001683_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001005_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000832_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003794_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000896_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001591_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003034_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003077_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004532_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002865_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000826_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000639_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000356_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001560_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003381_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000597_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000410_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003657_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000622_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003871_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002181_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004243_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000702_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003869_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003106_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000101_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001406_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001602_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003462_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001386_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003639_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002424_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004130_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000841_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000513_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004120_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001554_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000867_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002162_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000885_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001769_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004036_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003079_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002704_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003831_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003638_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000371_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003347_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003139_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001297_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002617_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003767_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001300_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000928_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003228_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004506_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001612_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002520_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001307_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001794_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001852_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002890_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000448_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000689_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000186_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002789_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000929_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004058_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001733_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004111_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003140_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000312_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004444_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002908_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004263_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001214_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001938_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003507_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002366_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002885_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004033_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000571_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000079_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002915_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003478_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002007_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004048_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004284_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003370_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001702_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002726_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000416_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000451_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001400_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002219_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002353_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002953_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004182_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002705_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001087_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004308_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000015_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003334_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000657_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001049_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001030_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002653_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004439_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004389_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002750_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003816_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000160_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000645_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002537_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001447_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004523_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003736_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001219_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003369_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003359_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002046_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002977_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002527_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004500_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003882_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003358_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003192_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000603_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002713_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000715_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000419_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001743_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001737_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000762_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000379_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002633_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003692_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003463_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003060_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002386_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001195_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001198_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003881_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000086_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002407_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000810_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000378_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001701_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002959_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004497_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004097_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002575_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002976_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003509_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002363_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003749_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003537_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000400_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004209_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003867_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003324_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000130_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002468_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004234_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000546_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003121_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000414_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001081_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000260_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000036_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004208_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000035_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000866_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003094_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000309_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001134_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003565_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001430_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001427_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004230_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000952_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001736_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000994_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003109_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001117_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003938_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001615_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004347_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002306_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000599_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000369_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000377_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000606_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001000_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001741_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000262_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000235_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002542_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003086_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002367_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001335_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000931_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000859_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003933_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000467_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001821_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000822_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000411_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000882_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001853_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002888_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003443_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001224_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004240_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004054_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000559_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002356_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002475_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004335_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002887_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002100_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002954_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000601_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001924_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003914_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000463_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002493_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003031_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002929_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001290_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000383_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/004363_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000389_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001241_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002591_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000141_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000742_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000230_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003592_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001205_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001697_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000313_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001026_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000171_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001181_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000549_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000064_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000242_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000129_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003711_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001248_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001237_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002482_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001650_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/000892_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/003238_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/002487_cam.txt" + string_val: "/users/lzr2019040707014/KITTI/data/00/001634_cam.txt" + } + } + } +} +node { + name: "data_loading/input_producer_1/Size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 5020 + } + } + } +} +node { + name: "data_loading/input_producer_1/Greater/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: 0 + } + } + } +} +node { + name: "data_loading/input_producer_1/Greater" + op: "Greater" + input: "data_loading/input_producer_1/Size" + input: "data_loading/input_producer_1/Greater/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/input_producer_1/Assert/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: "string_input_producer requires a non-null input tensor" + } + } + } +} +node { + name: "data_loading/input_producer_1/Assert/Assert/data_0" + 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: "string_input_producer requires a non-null input tensor" + } + } + } +} +node { + name: "data_loading/input_producer_1/Assert/Assert" + op: "Assert" + input: "data_loading/input_producer_1/Greater" + input: "data_loading/input_producer_1/Assert/Assert/data_0" + attr { + key: "T" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "summarize" + value { + i: 3 + } + } +} +node { + name: "data_loading/input_producer_1/Identity" + op: "Identity" + input: "data_loading/input_producer_1/Const" + input: "^data_loading/input_producer_1/Assert/Assert" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5020 + } + } + } + } + } +} +node { + name: "data_loading/input_producer_1/RandomShuffle" + op: "RandomShuffle" + input: "data_loading/input_producer_1/Identity" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5020 + } + } + } + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 431779219 + } + } +} +node { + name: "data_loading/input_producer_1" + op: "FIFOQueueV2" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "capacity" + value { + i: 32 + } + } + attr { + key: "component_types" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "data_loading/input_producer_1/input_producer_1_EnqueueMany" + op: "QueueEnqueueManyV2" + input: "data_loading/input_producer_1" + input: "data_loading/input_producer_1/RandomShuffle" + attr { + key: "Tcomponents" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "timeout_ms" + value { + i: -1 + } + } +} +node { + name: "data_loading/input_producer_1/input_producer_1_Close" + op: "QueueCloseV2" + input: "data_loading/input_producer_1" + attr { + key: "cancel_pending_enqueues" + value { + b: false + } + } +} +node { + name: "data_loading/input_producer_1/input_producer_1_Close_1" + op: "QueueCloseV2" + input: "data_loading/input_producer_1" + attr { + key: "cancel_pending_enqueues" + value { + b: true + } + } +} +node { + name: "data_loading/input_producer_1/input_producer_1_Size" + op: "QueueSizeV2" + input: "data_loading/input_producer_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/input_producer_1/ToFloat" + op: "Cast" + input: "data_loading/input_producer_1/input_producer_1_Size" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/input_producer_1/mul/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.03125 + } + } + } +} +node { + name: "data_loading/input_producer_1/mul" + op: "Mul" + input: "data_loading/input_producer_1/ToFloat" + input: "data_loading/input_producer_1/mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/input_producer_1/fraction_of_32_full/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: "data_loading/input_producer_1/fraction_of_32_full" + } + } + } +} +node { + name: "data_loading/input_producer_1/fraction_of_32_full" + op: "ScalarSummary" + input: "data_loading/input_producer_1/fraction_of_32_full/tags" + input: "data_loading/input_producer_1/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/WholeFileReaderV2" + op: "WholeFileReaderV2" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "data_loading/ReaderReadV2" + op: "ReaderReadV2" + input: "data_loading/WholeFileReaderV2" + input: "data_loading/input_producer" + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } +} +node { + name: "data_loading/DecodeJpeg" + op: "DecodeJpeg" + input: "data_loading/ReaderReadV2:1" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "acceptable_fraction" + value { + f: 1.0 + } + } + attr { + key: "channels" + value { + i: 0 + } + } + attr { + key: "dct_method" + value { + s: "" + } + } + attr { + key: "fancy_upscaling" + value { + b: true + } + } + attr { + key: "ratio" + value { + i: 1 + } + } + attr { + key: "try_recover_truncated" + value { + b: false + } + } +} +node { + name: "data_loading/Slice/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\240\001\000\000\000\000\000\000" + } + } + } +} +node { + name: "data_loading/Slice/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\240\001\000\000\377\377\377\377" + } + } + } +} +node { + name: "data_loading/Slice" + op: "Slice" + input: "data_loading/DecodeJpeg" + input: "data_loading/Slice/begin" + input: "data_loading/Slice/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "data_loading/Slice_1/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "data_loading/Slice_1/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\240\001\000\000\377\377\377\377" + } + } + } +} +node { + name: "data_loading/Slice_1" + op: "Slice" + input: "data_loading/DecodeJpeg" + input: "data_loading/Slice_1/begin" + input: "data_loading/Slice_1/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 416 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "data_loading/Slice_2/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000@\003\000\000\000\000\000\000" + } + } + } +} +node { + name: "data_loading/Slice_2/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\240\001\000\000\377\377\377\377" + } + } + } +} +node { + name: "data_loading/Slice_2" + op: "Slice" + input: "data_loading/DecodeJpeg" + input: "data_loading/Slice_2/begin" + input: "data_loading/Slice_2/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 416 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "data_loading/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "data_loading/concat" + op: "ConcatV2" + input: "data_loading/Slice_1" + input: "data_loading/Slice_2" + input: "data_loading/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 832 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "data_loading/Slice_3/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "data_loading/Slice_3/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\240\001\000\000\377\377\377\377" + } + } + } +} +node { + name: "data_loading/Slice_3" + op: "Slice" + input: "data_loading/concat" + input: "data_loading/Slice_3/begin" + input: "data_loading/Slice_3/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 416 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "data_loading/Slice_4/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\240\001\000\000\000\000\000\000" + } + } + } +} +node { + name: "data_loading/Slice_4/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\240\001\000\000\377\377\377\377" + } + } + } +} +node { + name: "data_loading/Slice_4" + op: "Slice" + input: "data_loading/concat" + input: "data_loading/Slice_4/begin" + input: "data_loading/Slice_4/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 416 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "data_loading/concat_1/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: 2 + } + } + } +} +node { + name: "data_loading/concat_1" + op: "ConcatV2" + input: "data_loading/Slice_3" + input: "data_loading/Slice_4" + input: "data_loading/concat_1/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "data_loading/TextLineReaderV2" + op: "TextLineReaderV2" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "shared_name" + value { + s: "" + } + } + attr { + key: "skip_header_lines" + value { + i: 0 + } + } +} +node { + name: "data_loading/ReaderReadV2_1" + op: "ReaderReadV2" + input: "data_loading/TextLineReaderV2" + input: "data_loading/input_producer_1" + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } +} +node { + name: "data_loading/DecodeCSV/record_defaults_0" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 1.0 + } + } + } +} +node { + name: "data_loading/DecodeCSV/record_defaults_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 1.0 + } + } + } +} +node { + name: "data_loading/DecodeCSV/record_defaults_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 1.0 + } + } + } +} +node { + name: "data_loading/DecodeCSV/record_defaults_3" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 1.0 + } + } + } +} +node { + name: "data_loading/DecodeCSV/record_defaults_4" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 1.0 + } + } + } +} +node { + name: "data_loading/DecodeCSV/record_defaults_5" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 1.0 + } + } + } +} +node { + name: "data_loading/DecodeCSV/record_defaults_6" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 1.0 + } + } + } +} +node { + name: "data_loading/DecodeCSV/record_defaults_7" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 1.0 + } + } + } +} +node { + name: "data_loading/DecodeCSV/record_defaults_8" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 1.0 + } + } + } +} +node { + name: "data_loading/DecodeCSV" + op: "DecodeCSV" + input: "data_loading/ReaderReadV2_1:1" + input: "data_loading/DecodeCSV/record_defaults_0" + input: "data_loading/DecodeCSV/record_defaults_1" + input: "data_loading/DecodeCSV/record_defaults_2" + input: "data_loading/DecodeCSV/record_defaults_3" + input: "data_loading/DecodeCSV/record_defaults_4" + input: "data_loading/DecodeCSV/record_defaults_5" + input: "data_loading/DecodeCSV/record_defaults_6" + input: "data_loading/DecodeCSV/record_defaults_7" + input: "data_loading/DecodeCSV/record_defaults_8" + attr { + key: "OUT_TYPE" + value { + list { + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + shape { + } + shape { + } + shape { + } + shape { + } + shape { + } + shape { + } + shape { + } + } + } + } + attr { + key: "field_delim" + value { + s: "," + } + } + attr { + key: "na_value" + value { + s: "" + } + } + attr { + key: "select_cols" + value { + list { + } + } + } + attr { + key: "use_quote_delim" + value { + b: true + } + } +} +node { + name: "data_loading/stack" + op: "Pack" + input: "data_loading/DecodeCSV" + input: "data_loading/DecodeCSV:1" + input: "data_loading/DecodeCSV:2" + input: "data_loading/DecodeCSV:3" + input: "data_loading/DecodeCSV:4" + input: "data_loading/DecodeCSV:5" + input: "data_loading/DecodeCSV:6" + input: "data_loading/DecodeCSV:7" + input: "data_loading/DecodeCSV:8" + attr { + key: "N" + value { + i: 9 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "data_loading/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\003\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "data_loading/Reshape" + op: "Reshape" + input: "data_loading/stack" + input: "data_loading/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: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "data_loading/batch/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_BOOL + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_BOOL + tensor_shape { + } + bool_val: true + } + } + } +} +node { + name: "data_loading/batch/fifo_queue" + op: "FIFOQueueV2" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "capacity" + value { + i: 32 + } + } + attr { + key: "component_types" + value { + list { + type: DT_UINT8 + type: DT_UINT8 + type: DT_FLOAT + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 6 + } + } + shape { + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "data_loading/batch/fifo_queue_enqueue" + op: "QueueEnqueueV2" + input: "data_loading/batch/fifo_queue" + input: "data_loading/concat_1" + input: "data_loading/Slice" + input: "data_loading/Reshape" + attr { + key: "Tcomponents" + value { + list { + type: DT_UINT8 + type: DT_UINT8 + type: DT_FLOAT + } + } + } + attr { + key: "timeout_ms" + value { + i: -1 + } + } +} +node { + name: "data_loading/batch/fifo_queue_Close" + op: "QueueCloseV2" + input: "data_loading/batch/fifo_queue" + attr { + key: "cancel_pending_enqueues" + value { + b: false + } + } +} +node { + name: "data_loading/batch/fifo_queue_Close_1" + op: "QueueCloseV2" + input: "data_loading/batch/fifo_queue" + attr { + key: "cancel_pending_enqueues" + value { + b: true + } + } +} +node { + name: "data_loading/batch/fifo_queue_Size" + op: "QueueSizeV2" + input: "data_loading/batch/fifo_queue" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/batch/ToFloat" + op: "Cast" + input: "data_loading/batch/fifo_queue_Size" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/batch/mul/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.03125 + } + } + } +} +node { + name: "data_loading/batch/mul" + op: "Mul" + input: "data_loading/batch/ToFloat" + input: "data_loading/batch/mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/batch/fraction_of_32_full/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: "data_loading/batch/fraction_of_32_full" + } + } + } +} +node { + name: "data_loading/batch/fraction_of_32_full" + op: "ScalarSummary" + input: "data_loading/batch/fraction_of_32_full/tags" + input: "data_loading/batch/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/batch/n" + 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: 4 + } + } + } +} +node { + name: "data_loading/batch" + op: "QueueDequeueManyV2" + input: "data_loading/batch/fifo_queue" + input: "data_loading/batch/n" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 6 + } + } + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "component_types" + value { + list { + type: DT_UINT8 + type: DT_UINT8 + type: DT_FLOAT + } + } + } + attr { + key: "timeout_ms" + value { + i: -1 + } + } +} +node { + name: "data_loading/concat_2/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: 3 + } + } + } +} +node { + name: "data_loading/concat_2" + op: "ConcatV2" + input: "data_loading/batch:1" + input: "data_loading/batch" + input: "data_loading/concat_2/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 9 + } + } + } + } + } +} +node { + name: "data_loading/random_uniform/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: 2 + } + } + } +} +node { + name: "data_loading/random_uniform/min" + 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: "data_loading/random_uniform/max" + 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.149999976158142 + } + } + } +} +node { + name: "data_loading/random_uniform/RandomUniform" + op: "RandomUniform" + input: "data_loading/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 93 + } + } +} +node { + name: "data_loading/random_uniform/sub" + op: "Sub" + input: "data_loading/random_uniform/max" + input: "data_loading/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/random_uniform/mul" + op: "Mul" + input: "data_loading/random_uniform/RandomUniform" + input: "data_loading/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "data_loading/random_uniform" + op: "Add" + input: "data_loading/random_uniform/mul" + input: "data_loading/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "data_loading/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: "data_loading/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: "data_loading/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: "data_loading/strided_slice" + op: "StridedSlice" + input: "data_loading/random_uniform" + input: "data_loading/strided_slice/stack" + input: "data_loading/strided_slice/stack_1" + input: "data_loading/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + 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: "data_loading/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: "data_loading/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: "data_loading/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: "data_loading/strided_slice_1" + op: "StridedSlice" + input: "data_loading/random_uniform" + input: "data_loading/strided_slice_1/stack" + input: "data_loading/strided_slice_1/stack_1" + input: "data_loading/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + 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: "data_loading/mul/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 128.0 + } + } + } +} +node { + name: "data_loading/mul" + op: "Mul" + input: "data_loading/mul/x" + input: "data_loading/strided_slice_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/Cast" + op: "Cast" + input: "data_loading/mul" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/mul_1/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 416.0 + } + } + } +} +node { + name: "data_loading/mul_1" + op: "Mul" + input: "data_loading/mul_1/x" + input: "data_loading/strided_slice" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/Cast_1" + op: "Cast" + input: "data_loading/mul_1" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/ResizeArea/size" + op: "Pack" + input: "data_loading/Cast" + input: "data_loading/Cast_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: "data_loading/ResizeArea" + op: "ResizeArea" + input: "data_loading/concat_2" + input: "data_loading/ResizeArea/size" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: 9 + } + } + } + } + } + attr { + key: "align_corners" + value { + b: false + } + } +} +node { + name: "data_loading/strided_slice_2/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_2/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_2/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_2" + op: "StridedSlice" + input: "data_loading/batch:2" + input: "data_loading/strided_slice_2/stack" + input: "data_loading/strided_slice_2/stack_1" + input: "data_loading/strided_slice_2/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/mul_2" + op: "Mul" + input: "data_loading/strided_slice_2" + input: "data_loading/strided_slice" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/strided_slice_3/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_3/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_3/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_3" + op: "StridedSlice" + input: "data_loading/batch:2" + input: "data_loading/strided_slice_3/stack" + input: "data_loading/strided_slice_3/stack_1" + input: "data_loading/strided_slice_3/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/mul_3" + op: "Mul" + input: "data_loading/strided_slice_3" + input: "data_loading/strided_slice_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/strided_slice_4/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_4/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_4/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_4" + op: "StridedSlice" + input: "data_loading/batch:2" + input: "data_loading/strided_slice_4/stack" + input: "data_loading/strided_slice_4/stack_1" + input: "data_loading/strided_slice_4/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/mul_4" + op: "Mul" + input: "data_loading/strided_slice_4" + input: "data_loading/strided_slice" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/strided_slice_5/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_5/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_5/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_5" + op: "StridedSlice" + input: "data_loading/batch:2" + input: "data_loading/strided_slice_5/stack" + input: "data_loading/strided_slice_5/stack_1" + input: "data_loading/strided_slice_5/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/mul_5" + op: "Mul" + input: "data_loading/strided_slice_5" + input: "data_loading/strided_slice_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/zeros_like" + op: "Const" + 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: "data_loading/stack_1" + op: "Pack" + input: "data_loading/mul_2" + input: "data_loading/zeros_like" + input: "data_loading/mul_4" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "axis" + value { + i: 1 + } + } +} +node { + name: "data_loading/stack_2" + op: "Pack" + input: "data_loading/zeros_like" + input: "data_loading/mul_3" + input: "data_loading/mul_5" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "axis" + value { + i: 1 + } + } +} +node { + name: "data_loading/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "data_loading/Tile/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/Tile" + op: "Tile" + input: "data_loading/Const" + input: "data_loading/Tile/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "data_loading/stack_3" + op: "Pack" + input: "data_loading/stack_1" + input: "data_loading/stack_2" + input: "data_loading/Tile" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "axis" + value { + i: 1 + } + } +} +node { + name: "data_loading/Shape" + op: "Shape" + input: "data_loading/ResizeArea" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "data_loading/unstack" + op: "Unpack" + input: "data_loading/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + shape { + } + shape { + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } + attr { + key: "num" + value { + i: 4 + } + } +} +node { + name: "data_loading/sub/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 128 + } + } + } +} +node { + name: "data_loading/sub" + op: "Sub" + input: "data_loading/unstack:1" + input: "data_loading/sub/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/add/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: "data_loading/add" + op: "Add" + input: "data_loading/sub" + input: "data_loading/add/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/random_uniform_1/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "data_loading/random_uniform_1/min" + 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: "data_loading/random_uniform_1" + op: "RandomUniformInt" + input: "data_loading/random_uniform_1/shape" + input: "data_loading/random_uniform_1/min" + input: "data_loading/add" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tout" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 148 + } + } +} +node { + name: "data_loading/strided_slice_6/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "data_loading/strided_slice_6/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "data_loading/strided_slice_6/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "data_loading/strided_slice_6" + op: "StridedSlice" + input: "data_loading/random_uniform_1" + input: "data_loading/strided_slice_6/stack" + input: "data_loading/strided_slice_6/stack_1" + input: "data_loading/strided_slice_6/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: "data_loading/sub_1/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: 416 + } + } + } +} +node { + name: "data_loading/sub_1" + op: "Sub" + input: "data_loading/unstack:2" + input: "data_loading/sub_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/add_1/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: "data_loading/add_1" + op: "Add" + input: "data_loading/sub_1" + input: "data_loading/add_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/random_uniform_2/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: "data_loading/random_uniform_2/min" + 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: "data_loading/random_uniform_2" + op: "RandomUniformInt" + input: "data_loading/random_uniform_2/shape" + input: "data_loading/random_uniform_2/min" + input: "data_loading/add_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tout" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 159 + } + } +} +node { + name: "data_loading/strided_slice_7/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "data_loading/strided_slice_7/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "data_loading/strided_slice_7/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "data_loading/strided_slice_7" + op: "StridedSlice" + input: "data_loading/random_uniform_2" + input: "data_loading/strided_slice_7/stack" + input: "data_loading/strided_slice_7/stack_1" + input: "data_loading/strided_slice_7/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: "data_loading/crop_to_bounding_box/Shape" + op: "Shape" + input: "data_loading/ResizeArea" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "data_loading/crop_to_bounding_box/assert_positive/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/assert_positive/assert_less/Less" + op: "Less" + input: "data_loading/crop_to_bounding_box/assert_positive/Const" + input: "data_loading/crop_to_bounding_box/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/assert_positive/assert_less/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: "data_loading/crop_to_bounding_box/assert_positive/assert_less/All" + op: "All" + input: "data_loading/crop_to_bounding_box/assert_positive/assert_less/Less" + input: "data_loading/crop_to_bounding_box/assert_positive/assert_less/Const" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "data_loading/crop_to_bounding_box/assert_positive/assert_less/Assert/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: "all dims of \'image.shape\' must be > 0." + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/assert_positive/assert_less/Assert/Assert/data_0" + 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: "all dims of \'image.shape\' must be > 0." + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/assert_positive/assert_less/Assert/Assert" + op: "Assert" + input: "data_loading/crop_to_bounding_box/assert_positive/assert_less/All" + input: "data_loading/crop_to_bounding_box/assert_positive/assert_less/Assert/Assert/data_0" + attr { + key: "T" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "summarize" + value { + i: 3 + } + } +} +node { + name: "data_loading/crop_to_bounding_box/Shape_1" + op: "Shape" + input: "data_loading/ResizeArea" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "data_loading/crop_to_bounding_box/unstack" + op: "Unpack" + input: "data_loading/crop_to_bounding_box/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + shape { + } + shape { + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } + attr { + key: "num" + value { + i: 4 + } + } +} +node { + name: "data_loading/crop_to_bounding_box/GreaterEqual/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: 0 + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/GreaterEqual" + op: "GreaterEqual" + input: "data_loading/strided_slice_7" + input: "data_loading/crop_to_bounding_box/GreaterEqual/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/Assert/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: "offset_width must be >= 0." + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/Assert/Assert/data_0" + 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: "offset_width must be >= 0." + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/Assert/Assert" + op: "Assert" + input: "data_loading/crop_to_bounding_box/GreaterEqual" + input: "data_loading/crop_to_bounding_box/Assert/Assert/data_0" + attr { + key: "T" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "summarize" + value { + i: 3 + } + } +} +node { + name: "data_loading/crop_to_bounding_box/GreaterEqual_1/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: 0 + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/GreaterEqual_1" + op: "GreaterEqual" + input: "data_loading/strided_slice_6" + input: "data_loading/crop_to_bounding_box/GreaterEqual_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/Assert_1/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: "offset_height must be >= 0." + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/Assert_1/Assert/data_0" + 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: "offset_height must be >= 0." + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/Assert_1/Assert" + op: "Assert" + input: "data_loading/crop_to_bounding_box/GreaterEqual_1" + input: "data_loading/crop_to_bounding_box/Assert_1/Assert/data_0" + attr { + key: "T" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "summarize" + value { + i: 3 + } + } +} +node { + name: "data_loading/crop_to_bounding_box/add/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 416 + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/add" + op: "Add" + input: "data_loading/crop_to_bounding_box/add/x" + input: "data_loading/strided_slice_7" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/GreaterEqual_2" + op: "GreaterEqual" + input: "data_loading/crop_to_bounding_box/unstack:2" + input: "data_loading/crop_to_bounding_box/add" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/Assert_2/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: "width must be >= target + offset." + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/Assert_2/Assert/data_0" + 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: "width must be >= target + offset." + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/Assert_2/Assert" + op: "Assert" + input: "data_loading/crop_to_bounding_box/GreaterEqual_2" + input: "data_loading/crop_to_bounding_box/Assert_2/Assert/data_0" + attr { + key: "T" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "summarize" + value { + i: 3 + } + } +} +node { + name: "data_loading/crop_to_bounding_box/add_1/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 128 + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/add_1" + op: "Add" + input: "data_loading/crop_to_bounding_box/add_1/x" + input: "data_loading/strided_slice_6" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/GreaterEqual_3" + op: "GreaterEqual" + input: "data_loading/crop_to_bounding_box/unstack:1" + input: "data_loading/crop_to_bounding_box/add_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/Assert_3/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: "height must be >= target + offset." + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/Assert_3/Assert/data_0" + 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: "height must be >= target + offset." + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/Assert_3/Assert" + op: "Assert" + input: "data_loading/crop_to_bounding_box/GreaterEqual_3" + input: "data_loading/crop_to_bounding_box/Assert_3/Assert/data_0" + attr { + key: "T" + value { + list { + type: DT_STRING + } + } + } + attr { + key: "summarize" + value { + i: 3 + } + } +} +node { + name: "data_loading/crop_to_bounding_box/control_dependency" + op: "Identity" + input: "data_loading/ResizeArea" + input: "^data_loading/crop_to_bounding_box/Assert/Assert" + input: "^data_loading/crop_to_bounding_box/Assert_1/Assert" + input: "^data_loading/crop_to_bounding_box/Assert_2/Assert" + input: "^data_loading/crop_to_bounding_box/Assert_3/Assert" + input: "^data_loading/crop_to_bounding_box/assert_positive/assert_less/Assert/Assert" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@data_loading/ResizeArea" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: 9 + } + } + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/stack/0" + 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: "data_loading/crop_to_bounding_box/stack/3" + 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: "data_loading/crop_to_bounding_box/stack" + op: "Pack" + input: "data_loading/crop_to_bounding_box/stack/0" + input: "data_loading/strided_slice_6" + input: "data_loading/strided_slice_7" + input: "data_loading/crop_to_bounding_box/stack/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "data_loading/crop_to_bounding_box/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\377\377\377\377\200\000\000\000\240\001\000\000\377\377\377\377" + } + } + } +} +node { + name: "data_loading/crop_to_bounding_box/Slice" + op: "Slice" + input: "data_loading/crop_to_bounding_box/control_dependency" + input: "data_loading/crop_to_bounding_box/stack" + input: "data_loading/crop_to_bounding_box/stack_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 9 + } + } + } + } + } +} +node { + name: "data_loading/strided_slice_8/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_8/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_8/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_8" + op: "StridedSlice" + input: "data_loading/stack_3" + input: "data_loading/strided_slice_8/stack" + input: "data_loading/strided_slice_8/stack_1" + input: "data_loading/strided_slice_8/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/strided_slice_9/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_9/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_9/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_9" + op: "StridedSlice" + input: "data_loading/stack_3" + input: "data_loading/strided_slice_9/stack" + input: "data_loading/strided_slice_9/stack_1" + input: "data_loading/strided_slice_9/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/strided_slice_10/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_10/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_10/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_10" + op: "StridedSlice" + input: "data_loading/stack_3" + input: "data_loading/strided_slice_10/stack" + input: "data_loading/strided_slice_10/stack_1" + input: "data_loading/strided_slice_10/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/Cast_2" + op: "Cast" + input: "data_loading/strided_slice_7" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/sub_2" + op: "Sub" + input: "data_loading/strided_slice_10" + input: "data_loading/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/strided_slice_11/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_11/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_11/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_11" + op: "StridedSlice" + input: "data_loading/stack_3" + input: "data_loading/strided_slice_11/stack" + input: "data_loading/strided_slice_11/stack_1" + input: "data_loading/strided_slice_11/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/Cast_3" + op: "Cast" + input: "data_loading/strided_slice_6" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "data_loading/sub_3" + op: "Sub" + input: "data_loading/strided_slice_11" + input: "data_loading/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/zeros_like_1" + op: "Const" + 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: "data_loading/stack_4" + op: "Pack" + input: "data_loading/strided_slice_8" + input: "data_loading/zeros_like_1" + input: "data_loading/sub_2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "axis" + value { + i: 1 + } + } +} +node { + name: "data_loading/stack_5" + op: "Pack" + input: "data_loading/zeros_like_1" + input: "data_loading/strided_slice_9" + input: "data_loading/sub_3" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "axis" + value { + i: 1 + } + } +} +node { + name: "data_loading/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "data_loading/Tile_1/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/Tile_1" + op: "Tile" + input: "data_loading/Const_1" + input: "data_loading/Tile_1/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "data_loading/stack_6" + op: "Pack" + input: "data_loading/stack_4" + input: "data_loading/stack_5" + input: "data_loading/Tile_1" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "axis" + value { + i: 1 + } + } +} +node { + name: "data_loading/Cast_4" + op: "Cast" + input: "data_loading/crop_to_bounding_box/Slice" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 9 + } + } + } + } + } +} +node { + name: "data_loading/strided_slice_12/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_12/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_12/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_12" + op: "StridedSlice" + input: "data_loading/Cast_4" + input: "data_loading/strided_slice_12/stack" + input: "data_loading/strided_slice_12/stack_1" + input: "data_loading/strided_slice_12/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "data_loading/strided_slice_13/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_13/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_13/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_13" + op: "StridedSlice" + input: "data_loading/Cast_4" + input: "data_loading/strided_slice_13/stack" + input: "data_loading/strided_slice_13/stack_1" + input: "data_loading/strided_slice_13/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "data_loading/strided_slice_14/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_14/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_14/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_14" + op: "StridedSlice" + input: "data_loading/stack_6" + input: "data_loading/strided_slice_14/stack" + input: "data_loading/strided_slice_14/stack_1" + input: "data_loading/strided_slice_14/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/truediv/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "data_loading/truediv" + op: "RealDiv" + input: "data_loading/strided_slice_14" + input: "data_loading/truediv/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/strided_slice_15/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_15/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_15/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_15" + op: "StridedSlice" + input: "data_loading/stack_6" + input: "data_loading/strided_slice_15/stack" + input: "data_loading/strided_slice_15/stack_1" + input: "data_loading/strided_slice_15/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/truediv_1/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "data_loading/truediv_1" + op: "RealDiv" + input: "data_loading/strided_slice_15" + input: "data_loading/truediv_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/strided_slice_16/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_16/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_16/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_16" + op: "StridedSlice" + input: "data_loading/stack_6" + input: "data_loading/strided_slice_16/stack" + input: "data_loading/strided_slice_16/stack_1" + input: "data_loading/strided_slice_16/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/truediv_2/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "data_loading/truediv_2" + op: "RealDiv" + input: "data_loading/strided_slice_16" + input: "data_loading/truediv_2/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/strided_slice_17/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_17/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_17/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_17" + op: "StridedSlice" + input: "data_loading/stack_6" + input: "data_loading/strided_slice_17/stack" + input: "data_loading/strided_slice_17/stack_1" + input: "data_loading/strided_slice_17/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/truediv_3/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "data_loading/truediv_3" + op: "RealDiv" + input: "data_loading/strided_slice_17" + input: "data_loading/truediv_3/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/zeros_like_2" + op: "Const" + 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: "data_loading/stack_7" + op: "Pack" + input: "data_loading/truediv" + input: "data_loading/zeros_like_2" + input: "data_loading/truediv_2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "axis" + value { + i: 1 + } + } +} +node { + name: "data_loading/stack_8" + op: "Pack" + input: "data_loading/zeros_like_2" + input: "data_loading/truediv_1" + input: "data_loading/truediv_3" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "axis" + value { + i: 1 + } + } +} +node { + name: "data_loading/Const_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "data_loading/Tile_2/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/Tile_2" + op: "Tile" + input: "data_loading/Const_2" + input: "data_loading/Tile_2/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "data_loading/stack_9" + op: "Pack" + input: "data_loading/stack_7" + input: "data_loading/stack_8" + input: "data_loading/Tile_2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "axis" + value { + i: 1 + } + } +} +node { + name: "data_loading/strided_slice_18/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_18/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_18/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_18" + op: "StridedSlice" + input: "data_loading/stack_6" + input: "data_loading/strided_slice_18/stack" + input: "data_loading/strided_slice_18/stack_1" + input: "data_loading/strided_slice_18/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/truediv_4/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "data_loading/truediv_4" + op: "RealDiv" + input: "data_loading/strided_slice_18" + input: "data_loading/truediv_4/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/strided_slice_19/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_19/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_19/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_19" + op: "StridedSlice" + input: "data_loading/stack_6" + input: "data_loading/strided_slice_19/stack" + input: "data_loading/strided_slice_19/stack_1" + input: "data_loading/strided_slice_19/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/truediv_5/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "data_loading/truediv_5" + op: "RealDiv" + input: "data_loading/strided_slice_19" + input: "data_loading/truediv_5/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/strided_slice_20/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_20/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_20/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_20" + op: "StridedSlice" + input: "data_loading/stack_6" + input: "data_loading/strided_slice_20/stack" + input: "data_loading/strided_slice_20/stack_1" + input: "data_loading/strided_slice_20/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/truediv_6/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "data_loading/truediv_6" + op: "RealDiv" + input: "data_loading/strided_slice_20" + input: "data_loading/truediv_6/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/strided_slice_21/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_21/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_21/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_21" + op: "StridedSlice" + input: "data_loading/stack_6" + input: "data_loading/strided_slice_21/stack" + input: "data_loading/strided_slice_21/stack_1" + input: "data_loading/strided_slice_21/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/truediv_7/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "data_loading/truediv_7" + op: "RealDiv" + input: "data_loading/strided_slice_21" + input: "data_loading/truediv_7/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/zeros_like_3" + op: "Const" + 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: "data_loading/stack_10" + op: "Pack" + input: "data_loading/truediv_4" + input: "data_loading/zeros_like_3" + input: "data_loading/truediv_6" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "axis" + value { + i: 1 + } + } +} +node { + name: "data_loading/stack_11" + op: "Pack" + input: "data_loading/zeros_like_3" + input: "data_loading/truediv_5" + input: "data_loading/truediv_7" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "axis" + value { + i: 1 + } + } +} +node { + name: "data_loading/Const_3" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "data_loading/Tile_3/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/Tile_3" + op: "Tile" + input: "data_loading/Const_3" + input: "data_loading/Tile_3/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "data_loading/stack_12" + op: "Pack" + input: "data_loading/stack_10" + input: "data_loading/stack_11" + input: "data_loading/Tile_3" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "axis" + value { + i: 1 + } + } +} +node { + name: "data_loading/strided_slice_22/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_22/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_22/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_22" + op: "StridedSlice" + input: "data_loading/stack_6" + input: "data_loading/strided_slice_22/stack" + input: "data_loading/strided_slice_22/stack_1" + input: "data_loading/strided_slice_22/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/truediv_8/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 4.0 + } + } + } +} +node { + name: "data_loading/truediv_8" + op: "RealDiv" + input: "data_loading/strided_slice_22" + input: "data_loading/truediv_8/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/strided_slice_23/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_23/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_23/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_23" + op: "StridedSlice" + input: "data_loading/stack_6" + input: "data_loading/strided_slice_23/stack" + input: "data_loading/strided_slice_23/stack_1" + input: "data_loading/strided_slice_23/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/truediv_9/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 4.0 + } + } + } +} +node { + name: "data_loading/truediv_9" + op: "RealDiv" + input: "data_loading/strided_slice_23" + input: "data_loading/truediv_9/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/strided_slice_24/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_24/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_24/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_24" + op: "StridedSlice" + input: "data_loading/stack_6" + input: "data_loading/strided_slice_24/stack" + input: "data_loading/strided_slice_24/stack_1" + input: "data_loading/strided_slice_24/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/truediv_10/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 4.0 + } + } + } +} +node { + name: "data_loading/truediv_10" + op: "RealDiv" + input: "data_loading/strided_slice_24" + input: "data_loading/truediv_10/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/strided_slice_25/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_25/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_25/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_25" + op: "StridedSlice" + input: "data_loading/stack_6" + input: "data_loading/strided_slice_25/stack" + input: "data_loading/strided_slice_25/stack_1" + input: "data_loading/strided_slice_25/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/truediv_11/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: 4.0 + } + } + } +} +node { + name: "data_loading/truediv_11" + op: "RealDiv" + input: "data_loading/strided_slice_25" + input: "data_loading/truediv_11/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/zeros_like_4" + op: "Const" + 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: "data_loading/stack_13" + op: "Pack" + input: "data_loading/truediv_8" + input: "data_loading/zeros_like_4" + input: "data_loading/truediv_10" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "axis" + value { + i: 1 + } + } +} +node { + name: "data_loading/stack_14" + op: "Pack" + input: "data_loading/zeros_like_4" + input: "data_loading/truediv_9" + input: "data_loading/truediv_11" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "axis" + value { + i: 1 + } + } +} +node { + name: "data_loading/Const_4" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "data_loading/Tile_4/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/Tile_4" + op: "Tile" + input: "data_loading/Const_4" + input: "data_loading/Tile_4/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "data_loading/stack_15" + op: "Pack" + input: "data_loading/stack_13" + input: "data_loading/stack_14" + input: "data_loading/Tile_4" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "axis" + value { + i: 1 + } + } +} +node { + name: "data_loading/strided_slice_26/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_26/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_26/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_26" + op: "StridedSlice" + input: "data_loading/stack_6" + input: "data_loading/strided_slice_26/stack" + input: "data_loading/strided_slice_26/stack_1" + input: "data_loading/strided_slice_26/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/truediv_12/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 8.0 + } + } + } +} +node { + name: "data_loading/truediv_12" + op: "RealDiv" + input: "data_loading/strided_slice_26" + input: "data_loading/truediv_12/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/strided_slice_27/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_27/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_27/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_27" + op: "StridedSlice" + input: "data_loading/stack_6" + input: "data_loading/strided_slice_27/stack" + input: "data_loading/strided_slice_27/stack_1" + input: "data_loading/strided_slice_27/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/truediv_13/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: 8.0 + } + } + } +} +node { + name: "data_loading/truediv_13" + op: "RealDiv" + input: "data_loading/strided_slice_27" + input: "data_loading/truediv_13/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/strided_slice_28/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_28/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_28/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_28" + op: "StridedSlice" + input: "data_loading/stack_6" + input: "data_loading/strided_slice_28/stack" + input: "data_loading/strided_slice_28/stack_1" + input: "data_loading/strided_slice_28/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/truediv_14/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: 8.0 + } + } + } +} +node { + name: "data_loading/truediv_14" + op: "RealDiv" + input: "data_loading/strided_slice_28" + input: "data_loading/truediv_14/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/strided_slice_29/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_29/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_29/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/strided_slice_29" + op: "StridedSlice" + input: "data_loading/stack_6" + input: "data_loading/strided_slice_29/stack" + input: "data_loading/strided_slice_29/stack_1" + input: "data_loading/strided_slice_29/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 1 + } + } + 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: 6 + } + } +} +node { + name: "data_loading/truediv_15/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: 8.0 + } + } + } +} +node { + name: "data_loading/truediv_15" + op: "RealDiv" + input: "data_loading/strided_slice_29" + input: "data_loading/truediv_15/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "data_loading/zeros_like_5" + op: "Const" + 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: "data_loading/stack_16" + op: "Pack" + input: "data_loading/truediv_12" + input: "data_loading/zeros_like_5" + input: "data_loading/truediv_14" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "axis" + value { + i: 1 + } + } +} +node { + name: "data_loading/stack_17" + op: "Pack" + input: "data_loading/zeros_like_5" + input: "data_loading/truediv_13" + input: "data_loading/truediv_15" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "axis" + value { + i: 1 + } + } +} +node { + name: "data_loading/Const_5" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "data_loading/Tile_5/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "data_loading/Tile_5" + op: "Tile" + input: "data_loading/Const_5" + input: "data_loading/Tile_5/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "data_loading/stack_18" + op: "Pack" + input: "data_loading/stack_16" + input: "data_loading/stack_17" + input: "data_loading/Tile_5" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "axis" + value { + i: 1 + } + } +} +node { + name: "data_loading/stack_19" + op: "Pack" + input: "data_loading/stack_9" + input: "data_loading/stack_12" + input: "data_loading/stack_15" + input: "data_loading/stack_18" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "axis" + value { + i: 1 + } + } +} +node { + name: "data_loading/convert_image/Cast" + op: "Cast" + input: "data_loading/strided_slice_12" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "data_loading/convert_image/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.003921568859368563 + } + } + } +} +node { + name: "data_loading/convert_image" + op: "Mul" + input: "data_loading/convert_image/Cast" + input: "data_loading/convert_image/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "data_loading/mul_6/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "data_loading/mul_6" + op: "Mul" + input: "data_loading/convert_image" + input: "data_loading/mul_6/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "data_loading/sub_4/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "data_loading/sub_4" + op: "Sub" + input: "data_loading/mul_6" + input: "data_loading/sub_4/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "data_loading/convert_image_1/Cast" + op: "Cast" + input: "data_loading/strided_slice_13" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "data_loading/convert_image_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.003921568859368563 + } + } + } +} +node { + name: "data_loading/convert_image_1" + op: "Mul" + input: "data_loading/convert_image_1/Cast" + input: "data_loading/convert_image_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "data_loading/mul_7/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "data_loading/mul_7" + op: "Mul" + input: "data_loading/convert_image_1" + input: "data_loading/mul_7/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "data_loading/sub_5/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "data_loading/sub_5" + op: "Sub" + input: "data_loading/mul_7" + input: "data_loading/sub_5/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "depth_net/cnv1/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\007\000\000\000\007\000\000\000\003\000\000\000 \000\000\000" + } + } + } +} +node { + name: "depth_net/cnv1/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + 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.05914847552776337 + } + } + } +} +node { + name: "depth_net/cnv1/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + 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.05914847552776337 + } + } + } +} +node { + name: "depth_net/cnv1/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/cnv1/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 380 + } + } +} +node { + name: "depth_net/cnv1/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/cnv1/weights/Initializer/random_uniform/max" + input: "depth_net/cnv1/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv1/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/cnv1/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/cnv1/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/cnv1/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/cnv1/weights/Initializer/random_uniform/mul" + input: "depth_net/cnv1/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/cnv1/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv1/weights/Assign" + op: "Assign" + input: "depth_net/cnv1/weights" + input: "depth_net/cnv1/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv1/weights/read" + op: "Identity" + input: "depth_net/cnv1/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv1/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + 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: "depth_prediction/depth_net/cnv1/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/cnv1/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv1/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/cnv1/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/cnv1/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv1/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 32 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv1/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv1/biases/Assign" + op: "Assign" + input: "depth_net/cnv1/biases" + input: "depth_net/cnv1/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv1/biases/read" + op: "Identity" + input: "depth_net/cnv1/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv1/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv1/Conv2D" + op: "Conv2D" + input: "data_loading/sub_4" + input: "depth_net/cnv1/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/cnv1/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/cnv1/Conv2D" + input: "depth_net/cnv1/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/cnv1/Relu" + op: "Relu" + input: "depth_prediction/depth_net/cnv1/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/cnv1b/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\007\000\000\000\007\000\000\000 \000\000\000 \000\000\000" + } + } + } +} +node { + name: "depth_net/cnv1b/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + 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.0437408871948719 + } + } + } +} +node { + name: "depth_net/cnv1b/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + 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.0437408871948719 + } + } + } +} +node { + name: "depth_net/cnv1b/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/cnv1b/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 401 + } + } +} +node { + name: "depth_net/cnv1b/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/cnv1b/weights/Initializer/random_uniform/max" + input: "depth_net/cnv1b/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv1b/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/cnv1b/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/cnv1b/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/cnv1b/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/cnv1b/weights/Initializer/random_uniform/mul" + input: "depth_net/cnv1b/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/cnv1b/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv1b/weights/Assign" + op: "Assign" + input: "depth_net/cnv1b/weights" + input: "depth_net/cnv1b/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv1b/weights/read" + op: "Identity" + input: "depth_net/cnv1b/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv1b/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + 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: "depth_prediction/depth_net/cnv1b/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/cnv1b/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv1b/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/cnv1b/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/cnv1b/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv1b/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 32 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv1b/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv1b/biases/Assign" + op: "Assign" + input: "depth_net/cnv1b/biases" + input: "depth_net/cnv1b/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv1b/biases/read" + op: "Identity" + input: "depth_net/cnv1b/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv1b/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv1b/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/cnv1/Relu" + input: "depth_net/cnv1b/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/cnv1b/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/cnv1b/Conv2D" + input: "depth_net/cnv1b/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/cnv1b/Relu" + op: "Relu" + input: "depth_prediction/depth_net/cnv1b/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/cnv2/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\005\000\000\000\005\000\000\000 \000\000\000@\000\000\000" + } + } + } +} +node { + name: "depth_net/cnv2/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + 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: "depth_net/cnv2/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + 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: "depth_net/cnv2/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/cnv2/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 422 + } + } +} +node { + name: "depth_net/cnv2/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/cnv2/weights/Initializer/random_uniform/max" + input: "depth_net/cnv2/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv2/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/cnv2/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/cnv2/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/cnv2/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/cnv2/weights/Initializer/random_uniform/mul" + input: "depth_net/cnv2/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/cnv2/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv2/weights/Assign" + op: "Assign" + input: "depth_net/cnv2/weights" + input: "depth_net/cnv2/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv2/weights/read" + op: "Identity" + input: "depth_net/cnv2/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv2/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + 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: "depth_prediction/depth_net/cnv2/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/cnv2/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv2/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/cnv2/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/cnv2/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv2/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 64 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv2/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv2/biases/Assign" + op: "Assign" + input: "depth_net/cnv2/biases" + input: "depth_net/cnv2/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv2/biases/read" + op: "Identity" + input: "depth_net/cnv2/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv2/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv2/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/cnv1b/Relu" + input: "depth_net/cnv2/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/cnv2/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/cnv2/Conv2D" + input: "depth_net/cnv2/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/cnv2/Relu" + op: "Relu" + input: "depth_prediction/depth_net/cnv2/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/cnv2b/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\005\000\000\000\005\000\000\000@\000\000\000@\000\000\000" + } + } + } +} +node { + name: "depth_net/cnv2b/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + 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.04330126941204071 + } + } + } +} +node { + name: "depth_net/cnv2b/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + 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.04330126941204071 + } + } + } +} +node { + name: "depth_net/cnv2b/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/cnv2b/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 443 + } + } +} +node { + name: "depth_net/cnv2b/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/cnv2b/weights/Initializer/random_uniform/max" + input: "depth_net/cnv2b/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv2b/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/cnv2b/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/cnv2b/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/cnv2b/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/cnv2b/weights/Initializer/random_uniform/mul" + input: "depth_net/cnv2b/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/cnv2b/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv2b/weights/Assign" + op: "Assign" + input: "depth_net/cnv2b/weights" + input: "depth_net/cnv2b/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv2b/weights/read" + op: "Identity" + input: "depth_net/cnv2b/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv2b/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + 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: "depth_prediction/depth_net/cnv2b/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/cnv2b/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv2b/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/cnv2b/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/cnv2b/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv2b/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 64 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv2b/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv2b/biases/Assign" + op: "Assign" + input: "depth_net/cnv2b/biases" + input: "depth_net/cnv2b/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv2b/biases/read" + op: "Identity" + input: "depth_net/cnv2b/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv2b/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv2b/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/cnv2/Relu" + input: "depth_net/cnv2b/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/cnv2b/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/cnv2b/Conv2D" + input: "depth_net/cnv2b/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/cnv2b/Relu" + op: "Relu" + input: "depth_prediction/depth_net/cnv2b/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/cnv3/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000@\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "depth_net/cnv3/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + 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.0589255653321743 + } + } + } +} +node { + name: "depth_net/cnv3/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + 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.0589255653321743 + } + } + } +} +node { + name: "depth_net/cnv3/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/cnv3/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 464 + } + } +} +node { + name: "depth_net/cnv3/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/cnv3/weights/Initializer/random_uniform/max" + input: "depth_net/cnv3/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv3/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/cnv3/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/cnv3/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/cnv3/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/cnv3/weights/Initializer/random_uniform/mul" + input: "depth_net/cnv3/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/cnv3/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv3/weights/Assign" + op: "Assign" + input: "depth_net/cnv3/weights" + input: "depth_net/cnv3/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv3/weights/read" + op: "Identity" + input: "depth_net/cnv3/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv3/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + 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: "depth_prediction/depth_net/cnv3/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/cnv3/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv3/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/cnv3/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/cnv3/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv3/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 128 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv3/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv3/biases/Assign" + op: "Assign" + input: "depth_net/cnv3/biases" + input: "depth_net/cnv3/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv3/biases/read" + op: "Identity" + input: "depth_net/cnv3/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv3/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv3/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/cnv2b/Relu" + input: "depth_net/cnv3/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/cnv3/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/cnv3/Conv2D" + input: "depth_net/cnv3/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/cnv3/Relu" + op: "Relu" + input: "depth_prediction/depth_net/cnv3/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/cnv3b/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "depth_net/cnv3b/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + 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.05103103816509247 + } + } + } +} +node { + name: "depth_net/cnv3b/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + 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.05103103816509247 + } + } + } +} +node { + name: "depth_net/cnv3b/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/cnv3b/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 485 + } + } +} +node { + name: "depth_net/cnv3b/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/cnv3b/weights/Initializer/random_uniform/max" + input: "depth_net/cnv3b/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv3b/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/cnv3b/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/cnv3b/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/cnv3b/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/cnv3b/weights/Initializer/random_uniform/mul" + input: "depth_net/cnv3b/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/cnv3b/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv3b/weights/Assign" + op: "Assign" + input: "depth_net/cnv3b/weights" + input: "depth_net/cnv3b/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv3b/weights/read" + op: "Identity" + input: "depth_net/cnv3b/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv3b/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + 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: "depth_prediction/depth_net/cnv3b/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/cnv3b/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv3b/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/cnv3b/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/cnv3b/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv3b/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 128 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv3b/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv3b/biases/Assign" + op: "Assign" + input: "depth_net/cnv3b/biases" + input: "depth_net/cnv3b/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv3b/biases/read" + op: "Identity" + input: "depth_net/cnv3b/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv3b/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv3b/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/cnv3/Relu" + input: "depth_net/cnv3b/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/cnv3b/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/cnv3b/Conv2D" + input: "depth_net/cnv3b/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/cnv3b/Relu" + op: "Relu" + input: "depth_prediction/depth_net/cnv3b/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/cnv4/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\000\001\000\000" + } + } + } +} +node { + name: "depth_net/cnv4/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + 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.0416666679084301 + } + } + } +} +node { + name: "depth_net/cnv4/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + 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.0416666679084301 + } + } + } +} +node { + name: "depth_net/cnv4/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/cnv4/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 506 + } + } +} +node { + name: "depth_net/cnv4/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/cnv4/weights/Initializer/random_uniform/max" + input: "depth_net/cnv4/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv4/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/cnv4/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/cnv4/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/cnv4/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/cnv4/weights/Initializer/random_uniform/mul" + input: "depth_net/cnv4/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/cnv4/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv4/weights/Assign" + op: "Assign" + input: "depth_net/cnv4/weights" + input: "depth_net/cnv4/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv4/weights/read" + op: "Identity" + input: "depth_net/cnv4/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv4/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + 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: "depth_prediction/depth_net/cnv4/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/cnv4/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv4/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/cnv4/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/cnv4/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv4/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv4/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv4/biases/Assign" + op: "Assign" + input: "depth_net/cnv4/biases" + input: "depth_net/cnv4/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv4/biases/read" + op: "Identity" + input: "depth_net/cnv4/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv4/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv4/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/cnv3b/Relu" + input: "depth_net/cnv4/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/cnv4/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/cnv4/Conv2D" + input: "depth_net/cnv4/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/cnv4/Relu" + op: "Relu" + input: "depth_prediction/depth_net/cnv4/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/cnv4b/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\001\000\000" + } + } + } +} +node { + name: "depth_net/cnv4b/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + 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.03608439117670059 + } + } + } +} +node { + name: "depth_net/cnv4b/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + 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.03608439117670059 + } + } + } +} +node { + name: "depth_net/cnv4b/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/cnv4b/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 527 + } + } +} +node { + name: "depth_net/cnv4b/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/cnv4b/weights/Initializer/random_uniform/max" + input: "depth_net/cnv4b/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv4b/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/cnv4b/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/cnv4b/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/cnv4b/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/cnv4b/weights/Initializer/random_uniform/mul" + input: "depth_net/cnv4b/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/cnv4b/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv4b/weights/Assign" + op: "Assign" + input: "depth_net/cnv4b/weights" + input: "depth_net/cnv4b/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv4b/weights/read" + op: "Identity" + input: "depth_net/cnv4b/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv4b/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + 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: "depth_prediction/depth_net/cnv4b/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/cnv4b/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv4b/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/cnv4b/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/cnv4b/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv4b/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv4b/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv4b/biases/Assign" + op: "Assign" + input: "depth_net/cnv4b/biases" + input: "depth_net/cnv4b/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv4b/biases/read" + op: "Identity" + input: "depth_net/cnv4b/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv4b/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv4b/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/cnv4/Relu" + input: "depth_net/cnv4b/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/cnv4b/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/cnv4b/Conv2D" + input: "depth_net/cnv4b/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/cnv4b/Relu" + op: "Relu" + input: "depth_prediction/depth_net/cnv4b/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/cnv5/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/cnv5/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + 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.02946278266608715 + } + } + } +} +node { + name: "depth_net/cnv5/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + 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.02946278266608715 + } + } + } +} +node { + name: "depth_net/cnv5/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/cnv5/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 548 + } + } +} +node { + name: "depth_net/cnv5/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/cnv5/weights/Initializer/random_uniform/max" + input: "depth_net/cnv5/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv5/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/cnv5/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/cnv5/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv5/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/cnv5/weights/Initializer/random_uniform/mul" + input: "depth_net/cnv5/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv5/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv5/weights/Assign" + op: "Assign" + input: "depth_net/cnv5/weights" + input: "depth_net/cnv5/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv5/weights/read" + op: "Identity" + input: "depth_net/cnv5/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv5/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + 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: "depth_prediction/depth_net/cnv5/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/cnv5/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv5/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/cnv5/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/cnv5/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv5/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv5/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv5/biases/Assign" + op: "Assign" + input: "depth_net/cnv5/biases" + input: "depth_net/cnv5/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv5/biases/read" + op: "Identity" + input: "depth_net/cnv5/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv5/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv5/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/cnv4b/Relu" + input: "depth_net/cnv5/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/cnv5/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/cnv5/Conv2D" + input: "depth_net/cnv5/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/cnv5/Relu" + op: "Relu" + input: "depth_prediction/depth_net/cnv5/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv5b/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/cnv5b/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + 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.025515519082546234 + } + } + } +} +node { + name: "depth_net/cnv5b/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + 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.025515519082546234 + } + } + } +} +node { + name: "depth_net/cnv5b/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/cnv5b/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 569 + } + } +} +node { + name: "depth_net/cnv5b/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/cnv5b/weights/Initializer/random_uniform/max" + input: "depth_net/cnv5b/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv5b/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/cnv5b/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/cnv5b/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv5b/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/cnv5b/weights/Initializer/random_uniform/mul" + input: "depth_net/cnv5b/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv5b/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv5b/weights/Assign" + op: "Assign" + input: "depth_net/cnv5b/weights" + input: "depth_net/cnv5b/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv5b/weights/read" + op: "Identity" + input: "depth_net/cnv5b/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv5b/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + 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: "depth_prediction/depth_net/cnv5b/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/cnv5b/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv5b/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/cnv5b/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/cnv5b/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv5b/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv5b/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv5b/biases/Assign" + op: "Assign" + input: "depth_net/cnv5b/biases" + input: "depth_net/cnv5b/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv5b/biases/read" + op: "Identity" + input: "depth_net/cnv5b/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv5b/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv5b/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/cnv5/Relu" + input: "depth_net/cnv5b/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/cnv5b/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/cnv5b/Conv2D" + input: "depth_net/cnv5b/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/cnv5b/Relu" + op: "Relu" + input: "depth_prediction/depth_net/cnv5b/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv6/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/cnv6/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + 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.025515519082546234 + } + } + } +} +node { + name: "depth_net/cnv6/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + 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.025515519082546234 + } + } + } +} +node { + name: "depth_net/cnv6/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/cnv6/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 590 + } + } +} +node { + name: "depth_net/cnv6/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/cnv6/weights/Initializer/random_uniform/max" + input: "depth_net/cnv6/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv6/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/cnv6/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/cnv6/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv6/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/cnv6/weights/Initializer/random_uniform/mul" + input: "depth_net/cnv6/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv6/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv6/weights/Assign" + op: "Assign" + input: "depth_net/cnv6/weights" + input: "depth_net/cnv6/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv6/weights/read" + op: "Identity" + input: "depth_net/cnv6/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv6/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + 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: "depth_prediction/depth_net/cnv6/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/cnv6/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv6/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/cnv6/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/cnv6/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv6/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv6/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv6/biases/Assign" + op: "Assign" + input: "depth_net/cnv6/biases" + input: "depth_net/cnv6/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv6/biases/read" + op: "Identity" + input: "depth_net/cnv6/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv6/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv6/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/cnv5b/Relu" + input: "depth_net/cnv6/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/cnv6/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/cnv6/Conv2D" + input: "depth_net/cnv6/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/cnv6/Relu" + op: "Relu" + input: "depth_prediction/depth_net/cnv6/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv6b/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/cnv6b/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + 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.025515519082546234 + } + } + } +} +node { + name: "depth_net/cnv6b/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + 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.025515519082546234 + } + } + } +} +node { + name: "depth_net/cnv6b/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/cnv6b/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 611 + } + } +} +node { + name: "depth_net/cnv6b/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/cnv6b/weights/Initializer/random_uniform/max" + input: "depth_net/cnv6b/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv6b/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/cnv6b/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/cnv6b/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv6b/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/cnv6b/weights/Initializer/random_uniform/mul" + input: "depth_net/cnv6b/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv6b/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv6b/weights/Assign" + op: "Assign" + input: "depth_net/cnv6b/weights" + input: "depth_net/cnv6b/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv6b/weights/read" + op: "Identity" + input: "depth_net/cnv6b/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv6b/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + 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: "depth_prediction/depth_net/cnv6b/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/cnv6b/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv6b/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/cnv6b/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/cnv6b/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv6b/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv6b/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv6b/biases/Assign" + op: "Assign" + input: "depth_net/cnv6b/biases" + input: "depth_net/cnv6b/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv6b/biases/read" + op: "Identity" + input: "depth_net/cnv6b/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv6b/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv6b/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/cnv6/Relu" + input: "depth_net/cnv6b/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/cnv6b/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/cnv6b/Conv2D" + input: "depth_net/cnv6b/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/cnv6b/Relu" + op: "Relu" + input: "depth_prediction/depth_net/cnv6b/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv7/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/cnv7/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + 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.025515519082546234 + } + } + } +} +node { + name: "depth_net/cnv7/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + 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.025515519082546234 + } + } + } +} +node { + name: "depth_net/cnv7/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/cnv7/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 632 + } + } +} +node { + name: "depth_net/cnv7/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/cnv7/weights/Initializer/random_uniform/max" + input: "depth_net/cnv7/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv7/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/cnv7/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/cnv7/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv7/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/cnv7/weights/Initializer/random_uniform/mul" + input: "depth_net/cnv7/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv7/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv7/weights/Assign" + op: "Assign" + input: "depth_net/cnv7/weights" + input: "depth_net/cnv7/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv7/weights/read" + op: "Identity" + input: "depth_net/cnv7/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv7/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + 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: "depth_prediction/depth_net/cnv7/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/cnv7/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv7/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/cnv7/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/cnv7/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv7/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv7/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv7/biases/Assign" + op: "Assign" + input: "depth_net/cnv7/biases" + input: "depth_net/cnv7/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv7/biases/read" + op: "Identity" + input: "depth_net/cnv7/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv7/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv7/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/cnv6b/Relu" + input: "depth_net/cnv7/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/cnv7/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/cnv7/Conv2D" + input: "depth_net/cnv7/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/cnv7/Relu" + op: "Relu" + input: "depth_prediction/depth_net/cnv7/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv7b/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/cnv7b/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + 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.025515519082546234 + } + } + } +} +node { + name: "depth_net/cnv7b/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + 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.025515519082546234 + } + } + } +} +node { + name: "depth_net/cnv7b/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/cnv7b/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 653 + } + } +} +node { + name: "depth_net/cnv7b/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/cnv7b/weights/Initializer/random_uniform/max" + input: "depth_net/cnv7b/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv7b/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/cnv7b/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/cnv7b/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv7b/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/cnv7b/weights/Initializer/random_uniform/mul" + input: "depth_net/cnv7b/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv7b/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv7b/weights/Assign" + op: "Assign" + input: "depth_net/cnv7b/weights" + input: "depth_net/cnv7b/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv7b/weights/read" + op: "Identity" + input: "depth_net/cnv7b/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv7b/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + 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: "depth_prediction/depth_net/cnv7b/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/cnv7b/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv7b/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/cnv7b/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/cnv7b/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv7b/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv7b/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv7b/biases/Assign" + op: "Assign" + input: "depth_net/cnv7b/biases" + input: "depth_net/cnv7b/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv7b/biases/read" + op: "Identity" + input: "depth_net/cnv7b/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv7b/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/cnv7b/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/cnv7/Relu" + input: "depth_net/cnv7b/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/cnv7b/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/cnv7b/Conv2D" + input: "depth_net/cnv7b/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/cnv7b/Relu" + op: "Relu" + input: "depth_prediction/depth_net/cnv7b/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv7/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/upcnv7/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + 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.025515519082546234 + } + } + } +} +node { + name: "depth_net/upcnv7/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + 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.025515519082546234 + } + } + } +} +node { + name: "depth_net/upcnv7/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/upcnv7/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 674 + } + } +} +node { + name: "depth_net/upcnv7/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/upcnv7/weights/Initializer/random_uniform/max" + input: "depth_net/upcnv7/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/upcnv7/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/upcnv7/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/upcnv7/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv7/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/upcnv7/weights/Initializer/random_uniform/mul" + input: "depth_net/upcnv7/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv7/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv7/weights/Assign" + op: "Assign" + input: "depth_net/upcnv7/weights" + input: "depth_net/upcnv7/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv7/weights/read" + op: "Identity" + input: "depth_net/upcnv7/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv7/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + 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: "depth_prediction/depth_net/upcnv7/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/upcnv7/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv7/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/upcnv7/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/upcnv7/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/upcnv7/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv7/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv7/biases/Assign" + op: "Assign" + input: "depth_net/upcnv7/biases" + input: "depth_net/upcnv7/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv7/biases/read" + op: "Identity" + input: "depth_net/upcnv7/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv7/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\004\000\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv7/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: "depth_prediction/depth_net/upcnv7/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: "depth_prediction/depth_net/upcnv7/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: "depth_prediction/depth_net/upcnv7/strided_slice" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv7/Shape" + input: "depth_prediction/depth_net/upcnv7/strided_slice/stack" + input: "depth_prediction/depth_net/upcnv7/strided_slice/stack_1" + input: "depth_prediction/depth_net/upcnv7/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: "depth_prediction/depth_net/upcnv7/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: "depth_prediction/depth_net/upcnv7/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: "depth_prediction/depth_net/upcnv7/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: "depth_prediction/depth_net/upcnv7/strided_slice_1" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv7/Shape" + input: "depth_prediction/depth_net/upcnv7/strided_slice_1/stack" + input: "depth_prediction/depth_net/upcnv7/strided_slice_1/stack_1" + input: "depth_prediction/depth_net/upcnv7/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: "depth_prediction/depth_net/upcnv7/strided_slice_2/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv7/strided_slice_2/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv7/strided_slice_2/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv7/strided_slice_2" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv7/Shape" + input: "depth_prediction/depth_net/upcnv7/strided_slice_2/stack" + input: "depth_prediction/depth_net/upcnv7/strided_slice_2/stack_1" + input: "depth_prediction/depth_net/upcnv7/strided_slice_2/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: "depth_prediction/depth_net/upcnv7/mul/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: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv7/mul" + op: "Mul" + input: "depth_prediction/depth_net/upcnv7/strided_slice_1" + input: "depth_prediction/depth_net/upcnv7/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv7/mul_1/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: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv7/mul_1" + op: "Mul" + input: "depth_prediction/depth_net/upcnv7/strided_slice_2" + input: "depth_prediction/depth_net/upcnv7/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv7/stack/3" + 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: 512 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv7/stack" + op: "Pack" + input: "depth_prediction/depth_net/upcnv7/strided_slice" + input: "depth_prediction/depth_net/upcnv7/mul" + input: "depth_prediction/depth_net/upcnv7/mul_1" + input: "depth_prediction/depth_net/upcnv7/stack/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "depth_prediction/depth_net/upcnv7/conv2d_transpose" + op: "Conv2DBackpropInput" + input: "depth_prediction/depth_net/upcnv7/stack" + input: "depth_net/upcnv7/weights/read" + input: "depth_prediction/depth_net/cnv7b/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 8 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/upcnv7/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/upcnv7/conv2d_transpose" + input: "depth_net/upcnv7/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 8 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/upcnv7/Relu" + op: "Relu" + input: "depth_prediction/depth_net/upcnv7/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 8 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/ResizeNearestNeighbor/size" + 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: "\002\000\000\000\007\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/ResizeNearestNeighbor" + op: "ResizeNearestNeighbor" + input: "depth_prediction/depth_net/upcnv7/Relu" + input: "depth_prediction/depth_net/ResizeNearestNeighbor/size" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "align_corners" + value { + b: false + } + } +} +node { + name: "depth_prediction/depth_net/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: 3 + } + } + } +} +node { + name: "depth_prediction/depth_net/concat" + op: "ConcatV2" + input: "depth_prediction/depth_net/ResizeNearestNeighbor" + input: "depth_prediction/depth_net/cnv6b/Relu" + input: "depth_prediction/depth_net/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 1024 + } + } + } + } + } +} +node { + name: "depth_net/icnv7/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\004\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/icnv7/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + 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.02083333395421505 + } + } + } +} +node { + name: "depth_net/icnv7/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + 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.02083333395421505 + } + } + } +} +node { + name: "depth_net/icnv7/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/icnv7/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 717 + } + } +} +node { + name: "depth_net/icnv7/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/icnv7/weights/Initializer/random_uniform/max" + input: "depth_net/icnv7/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/icnv7/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/icnv7/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/icnv7/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/icnv7/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/icnv7/weights/Initializer/random_uniform/mul" + input: "depth_net/icnv7/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/icnv7/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv7/weights/Assign" + op: "Assign" + input: "depth_net/icnv7/weights" + input: "depth_net/icnv7/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv7/weights/read" + op: "Identity" + input: "depth_net/icnv7/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv7/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + 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: "depth_prediction/depth_net/icnv7/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/icnv7/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv7/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/icnv7/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/icnv7/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/icnv7/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv7/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv7/biases/Assign" + op: "Assign" + input: "depth_net/icnv7/biases" + input: "depth_net/icnv7/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv7/biases/read" + op: "Identity" + input: "depth_net/icnv7/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv7/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv7/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/concat" + input: "depth_net/icnv7/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/icnv7/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/icnv7/Conv2D" + input: "depth_net/icnv7/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/icnv7/Relu" + op: "Relu" + input: "depth_prediction/depth_net/icnv7/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv6/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/upcnv6/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + 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.025515519082546234 + } + } + } +} +node { + name: "depth_net/upcnv6/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + 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.025515519082546234 + } + } + } +} +node { + name: "depth_net/upcnv6/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/upcnv6/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 738 + } + } +} +node { + name: "depth_net/upcnv6/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/upcnv6/weights/Initializer/random_uniform/max" + input: "depth_net/upcnv6/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/upcnv6/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/upcnv6/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/upcnv6/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv6/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/upcnv6/weights/Initializer/random_uniform/mul" + input: "depth_net/upcnv6/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv6/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv6/weights/Assign" + op: "Assign" + input: "depth_net/upcnv6/weights" + input: "depth_net/upcnv6/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv6/weights/read" + op: "Identity" + input: "depth_net/upcnv6/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv6/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + 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: "depth_prediction/depth_net/upcnv6/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/upcnv6/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv6/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/upcnv6/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/upcnv6/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/upcnv6/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv6/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv6/biases/Assign" + op: "Assign" + input: "depth_net/upcnv6/biases" + input: "depth_net/upcnv6/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv6/biases/read" + op: "Identity" + input: "depth_net/upcnv6/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv6/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\007\000\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv6/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: "depth_prediction/depth_net/upcnv6/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: "depth_prediction/depth_net/upcnv6/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: "depth_prediction/depth_net/upcnv6/strided_slice" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv6/Shape" + input: "depth_prediction/depth_net/upcnv6/strided_slice/stack" + input: "depth_prediction/depth_net/upcnv6/strided_slice/stack_1" + input: "depth_prediction/depth_net/upcnv6/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: "depth_prediction/depth_net/upcnv6/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: "depth_prediction/depth_net/upcnv6/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: "depth_prediction/depth_net/upcnv6/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: "depth_prediction/depth_net/upcnv6/strided_slice_1" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv6/Shape" + input: "depth_prediction/depth_net/upcnv6/strided_slice_1/stack" + input: "depth_prediction/depth_net/upcnv6/strided_slice_1/stack_1" + input: "depth_prediction/depth_net/upcnv6/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: "depth_prediction/depth_net/upcnv6/strided_slice_2/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv6/strided_slice_2/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv6/strided_slice_2/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv6/strided_slice_2" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv6/Shape" + input: "depth_prediction/depth_net/upcnv6/strided_slice_2/stack" + input: "depth_prediction/depth_net/upcnv6/strided_slice_2/stack_1" + input: "depth_prediction/depth_net/upcnv6/strided_slice_2/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: "depth_prediction/depth_net/upcnv6/mul/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: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv6/mul" + op: "Mul" + input: "depth_prediction/depth_net/upcnv6/strided_slice_1" + input: "depth_prediction/depth_net/upcnv6/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv6/mul_1/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: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv6/mul_1" + op: "Mul" + input: "depth_prediction/depth_net/upcnv6/strided_slice_2" + input: "depth_prediction/depth_net/upcnv6/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv6/stack/3" + 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: 512 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv6/stack" + op: "Pack" + input: "depth_prediction/depth_net/upcnv6/strided_slice" + input: "depth_prediction/depth_net/upcnv6/mul" + input: "depth_prediction/depth_net/upcnv6/mul_1" + input: "depth_prediction/depth_net/upcnv6/stack/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "depth_prediction/depth_net/upcnv6/conv2d_transpose" + op: "Conv2DBackpropInput" + input: "depth_prediction/depth_net/upcnv6/stack" + input: "depth_net/upcnv6/weights/read" + input: "depth_prediction/depth_net/icnv7/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 14 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/upcnv6/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/upcnv6/conv2d_transpose" + input: "depth_net/upcnv6/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 14 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/upcnv6/Relu" + op: "Relu" + input: "depth_prediction/depth_net/upcnv6/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 14 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/ResizeNearestNeighbor_1/size" + 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: "\004\000\000\000\r\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/ResizeNearestNeighbor_1" + op: "ResizeNearestNeighbor" + input: "depth_prediction/depth_net/upcnv6/Relu" + input: "depth_prediction/depth_net/ResizeNearestNeighbor_1/size" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "align_corners" + value { + b: false + } + } +} +node { + name: "depth_prediction/depth_net/concat_1/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: 3 + } + } + } +} +node { + name: "depth_prediction/depth_net/concat_1" + op: "ConcatV2" + input: "depth_prediction/depth_net/ResizeNearestNeighbor_1" + input: "depth_prediction/depth_net/cnv5b/Relu" + input: "depth_prediction/depth_net/concat_1/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 1024 + } + } + } + } + } +} +node { + name: "depth_net/icnv6/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\004\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/icnv6/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + 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.02083333395421505 + } + } + } +} +node { + name: "depth_net/icnv6/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + 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.02083333395421505 + } + } + } +} +node { + name: "depth_net/icnv6/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/icnv6/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 781 + } + } +} +node { + name: "depth_net/icnv6/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/icnv6/weights/Initializer/random_uniform/max" + input: "depth_net/icnv6/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/icnv6/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/icnv6/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/icnv6/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/icnv6/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/icnv6/weights/Initializer/random_uniform/mul" + input: "depth_net/icnv6/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/icnv6/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv6/weights/Assign" + op: "Assign" + input: "depth_net/icnv6/weights" + input: "depth_net/icnv6/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv6/weights/read" + op: "Identity" + input: "depth_net/icnv6/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv6/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + 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: "depth_prediction/depth_net/icnv6/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/icnv6/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv6/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/icnv6/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/icnv6/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/icnv6/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv6/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv6/biases/Assign" + op: "Assign" + input: "depth_net/icnv6/biases" + input: "depth_net/icnv6/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv6/biases/read" + op: "Identity" + input: "depth_net/icnv6/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv6/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv6/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/concat_1" + input: "depth_net/icnv6/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/icnv6/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/icnv6/Conv2D" + input: "depth_net/icnv6/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/icnv6/Relu" + op: "Relu" + input: "depth_prediction/depth_net/icnv6/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv5/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/upcnv5/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + 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.02946278266608715 + } + } + } +} +node { + name: "depth_net/upcnv5/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + 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.02946278266608715 + } + } + } +} +node { + name: "depth_net/upcnv5/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/upcnv5/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 802 + } + } +} +node { + name: "depth_net/upcnv5/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/upcnv5/weights/Initializer/random_uniform/max" + input: "depth_net/upcnv5/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/upcnv5/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/upcnv5/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/upcnv5/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv5/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/upcnv5/weights/Initializer/random_uniform/mul" + input: "depth_net/upcnv5/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv5/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv5/weights/Assign" + op: "Assign" + input: "depth_net/upcnv5/weights" + input: "depth_net/upcnv5/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv5/weights/read" + op: "Identity" + input: "depth_net/upcnv5/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv5/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + 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: "depth_prediction/depth_net/upcnv5/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/upcnv5/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv5/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/upcnv5/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/upcnv5/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/upcnv5/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv5/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv5/biases/Assign" + op: "Assign" + input: "depth_net/upcnv5/biases" + input: "depth_net/upcnv5/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv5/biases/read" + op: "Identity" + input: "depth_net/upcnv5/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv5/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\r\000\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv5/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: "depth_prediction/depth_net/upcnv5/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: "depth_prediction/depth_net/upcnv5/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: "depth_prediction/depth_net/upcnv5/strided_slice" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv5/Shape" + input: "depth_prediction/depth_net/upcnv5/strided_slice/stack" + input: "depth_prediction/depth_net/upcnv5/strided_slice/stack_1" + input: "depth_prediction/depth_net/upcnv5/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: "depth_prediction/depth_net/upcnv5/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: "depth_prediction/depth_net/upcnv5/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: "depth_prediction/depth_net/upcnv5/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: "depth_prediction/depth_net/upcnv5/strided_slice_1" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv5/Shape" + input: "depth_prediction/depth_net/upcnv5/strided_slice_1/stack" + input: "depth_prediction/depth_net/upcnv5/strided_slice_1/stack_1" + input: "depth_prediction/depth_net/upcnv5/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: "depth_prediction/depth_net/upcnv5/strided_slice_2/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv5/strided_slice_2/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv5/strided_slice_2/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv5/strided_slice_2" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv5/Shape" + input: "depth_prediction/depth_net/upcnv5/strided_slice_2/stack" + input: "depth_prediction/depth_net/upcnv5/strided_slice_2/stack_1" + input: "depth_prediction/depth_net/upcnv5/strided_slice_2/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: "depth_prediction/depth_net/upcnv5/mul/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: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv5/mul" + op: "Mul" + input: "depth_prediction/depth_net/upcnv5/strided_slice_1" + input: "depth_prediction/depth_net/upcnv5/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv5/mul_1/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: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv5/mul_1" + op: "Mul" + input: "depth_prediction/depth_net/upcnv5/strided_slice_2" + input: "depth_prediction/depth_net/upcnv5/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv5/stack/3" + 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: 256 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv5/stack" + op: "Pack" + input: "depth_prediction/depth_net/upcnv5/strided_slice" + input: "depth_prediction/depth_net/upcnv5/mul" + input: "depth_prediction/depth_net/upcnv5/mul_1" + input: "depth_prediction/depth_net/upcnv5/stack/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "depth_prediction/depth_net/upcnv5/conv2d_transpose" + op: "Conv2DBackpropInput" + input: "depth_prediction/depth_net/upcnv5/stack" + input: "depth_net/upcnv5/weights/read" + input: "depth_prediction/depth_net/icnv6/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/upcnv5/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/upcnv5/conv2d_transpose" + input: "depth_net/upcnv5/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/upcnv5/Relu" + op: "Relu" + input: "depth_prediction/depth_net/upcnv5/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/concat_2/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: 3 + } + } + } +} +node { + name: "depth_prediction/depth_net/concat_2" + op: "ConcatV2" + input: "depth_prediction/depth_net/upcnv5/Relu" + input: "depth_prediction/depth_net/cnv4b/Relu" + input: "depth_prediction/depth_net/concat_2/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/icnv5/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\001\000\000" + } + } + } +} +node { + name: "depth_net/icnv5/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + 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.02946278266608715 + } + } + } +} +node { + name: "depth_net/icnv5/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + 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.02946278266608715 + } + } + } +} +node { + name: "depth_net/icnv5/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/icnv5/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 843 + } + } +} +node { + name: "depth_net/icnv5/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/icnv5/weights/Initializer/random_uniform/max" + input: "depth_net/icnv5/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/icnv5/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/icnv5/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/icnv5/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/icnv5/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/icnv5/weights/Initializer/random_uniform/mul" + input: "depth_net/icnv5/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/icnv5/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv5/weights/Assign" + op: "Assign" + input: "depth_net/icnv5/weights" + input: "depth_net/icnv5/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv5/weights/read" + op: "Identity" + input: "depth_net/icnv5/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv5/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + 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: "depth_prediction/depth_net/icnv5/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/icnv5/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv5/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/icnv5/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/icnv5/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/icnv5/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv5/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv5/biases/Assign" + op: "Assign" + input: "depth_net/icnv5/biases" + input: "depth_net/icnv5/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv5/biases/read" + op: "Identity" + input: "depth_net/icnv5/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv5/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv5/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/concat_2" + input: "depth_net/icnv5/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/icnv5/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/icnv5/Conv2D" + input: "depth_net/icnv5/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/icnv5/Relu" + op: "Relu" + input: "depth_prediction/depth_net/icnv5/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/upcnv4/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\000\001\000\000" + } + } + } +} +node { + name: "depth_net/upcnv4/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + 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.0416666679084301 + } + } + } +} +node { + name: "depth_net/upcnv4/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + 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.0416666679084301 + } + } + } +} +node { + name: "depth_net/upcnv4/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/upcnv4/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 864 + } + } +} +node { + name: "depth_net/upcnv4/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/upcnv4/weights/Initializer/random_uniform/max" + input: "depth_net/upcnv4/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/upcnv4/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/upcnv4/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/upcnv4/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/upcnv4/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/upcnv4/weights/Initializer/random_uniform/mul" + input: "depth_net/upcnv4/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/upcnv4/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv4/weights/Assign" + op: "Assign" + input: "depth_net/upcnv4/weights" + input: "depth_net/upcnv4/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv4/weights/read" + op: "Identity" + input: "depth_net/upcnv4/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv4/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + 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: "depth_prediction/depth_net/upcnv4/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/upcnv4/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv4/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/upcnv4/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/upcnv4/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/upcnv4/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 128 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv4/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv4/biases/Assign" + op: "Assign" + input: "depth_net/upcnv4/biases" + input: "depth_net/upcnv4/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv4/biases/read" + op: "Identity" + input: "depth_net/upcnv4/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv4/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\010\000\000\000\032\000\000\000\000\001\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv4/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: "depth_prediction/depth_net/upcnv4/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: "depth_prediction/depth_net/upcnv4/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: "depth_prediction/depth_net/upcnv4/strided_slice" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv4/Shape" + input: "depth_prediction/depth_net/upcnv4/strided_slice/stack" + input: "depth_prediction/depth_net/upcnv4/strided_slice/stack_1" + input: "depth_prediction/depth_net/upcnv4/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: "depth_prediction/depth_net/upcnv4/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: "depth_prediction/depth_net/upcnv4/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: "depth_prediction/depth_net/upcnv4/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: "depth_prediction/depth_net/upcnv4/strided_slice_1" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv4/Shape" + input: "depth_prediction/depth_net/upcnv4/strided_slice_1/stack" + input: "depth_prediction/depth_net/upcnv4/strided_slice_1/stack_1" + input: "depth_prediction/depth_net/upcnv4/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: "depth_prediction/depth_net/upcnv4/strided_slice_2/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv4/strided_slice_2/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv4/strided_slice_2/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv4/strided_slice_2" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv4/Shape" + input: "depth_prediction/depth_net/upcnv4/strided_slice_2/stack" + input: "depth_prediction/depth_net/upcnv4/strided_slice_2/stack_1" + input: "depth_prediction/depth_net/upcnv4/strided_slice_2/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: "depth_prediction/depth_net/upcnv4/mul/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: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv4/mul" + op: "Mul" + input: "depth_prediction/depth_net/upcnv4/strided_slice_1" + input: "depth_prediction/depth_net/upcnv4/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv4/mul_1/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: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv4/mul_1" + op: "Mul" + input: "depth_prediction/depth_net/upcnv4/strided_slice_2" + input: "depth_prediction/depth_net/upcnv4/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv4/stack/3" + 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: 128 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv4/stack" + op: "Pack" + input: "depth_prediction/depth_net/upcnv4/strided_slice" + input: "depth_prediction/depth_net/upcnv4/mul" + input: "depth_prediction/depth_net/upcnv4/mul_1" + input: "depth_prediction/depth_net/upcnv4/stack/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "depth_prediction/depth_net/upcnv4/conv2d_transpose" + op: "Conv2DBackpropInput" + input: "depth_prediction/depth_net/upcnv4/stack" + input: "depth_net/upcnv4/weights/read" + input: "depth_prediction/depth_net/icnv5/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/upcnv4/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/upcnv4/conv2d_transpose" + input: "depth_net/upcnv4/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/upcnv4/Relu" + op: "Relu" + input: "depth_prediction/depth_net/upcnv4/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/concat_3/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: 3 + } + } + } +} +node { + name: "depth_prediction/depth_net/concat_3" + op: "ConcatV2" + input: "depth_prediction/depth_net/upcnv4/Relu" + input: "depth_prediction/depth_net/cnv3b/Relu" + input: "depth_prediction/depth_net/concat_3/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/icnv4/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\200\000\000\000" + } + } + } +} +node { + name: "depth_net/icnv4/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + 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.0416666679084301 + } + } + } +} +node { + name: "depth_net/icnv4/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + 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.0416666679084301 + } + } + } +} +node { + name: "depth_net/icnv4/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/icnv4/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 905 + } + } +} +node { + name: "depth_net/icnv4/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/icnv4/weights/Initializer/random_uniform/max" + input: "depth_net/icnv4/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/icnv4/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/icnv4/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/icnv4/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/icnv4/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/icnv4/weights/Initializer/random_uniform/mul" + input: "depth_net/icnv4/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/icnv4/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv4/weights/Assign" + op: "Assign" + input: "depth_net/icnv4/weights" + input: "depth_net/icnv4/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv4/weights/read" + op: "Identity" + input: "depth_net/icnv4/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv4/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + 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: "depth_prediction/depth_net/icnv4/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/icnv4/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv4/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/icnv4/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/icnv4/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/icnv4/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 128 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv4/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv4/biases/Assign" + op: "Assign" + input: "depth_net/icnv4/biases" + input: "depth_net/icnv4/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv4/biases/read" + op: "Identity" + input: "depth_net/icnv4/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv4/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv4/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/concat_3" + input: "depth_net/icnv4/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/icnv4/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/icnv4/Conv2D" + input: "depth_net/icnv4/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/icnv4/Relu" + op: "Relu" + input: "depth_prediction/depth_net/icnv4/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/disp4/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_net/disp4/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + 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.0718885138630867 + } + } + } +} +node { + name: "depth_net/disp4/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + 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.0718885138630867 + } + } + } +} +node { + name: "depth_net/disp4/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/disp4/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 926 + } + } +} +node { + name: "depth_net/disp4/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/disp4/weights/Initializer/random_uniform/max" + input: "depth_net/disp4/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/disp4/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/disp4/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/disp4/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp4/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/disp4/weights/Initializer/random_uniform/mul" + input: "depth_net/disp4/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp4/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp4/weights/Assign" + op: "Assign" + input: "depth_net/disp4/weights" + input: "depth_net/disp4/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp4/weights/read" + op: "Identity" + input: "depth_net/disp4/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/disp4/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + 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: "depth_prediction/depth_net/disp4/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/disp4/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/disp4/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/disp4/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/disp4/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/disp4/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/disp4/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp4/biases/Assign" + op: "Assign" + input: "depth_net/disp4/biases" + input: "depth_net/disp4/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp4/biases/read" + op: "Identity" + input: "depth_net/disp4/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/disp4/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/disp4/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/icnv4/Relu" + input: "depth_net/disp4/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/disp4/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/disp4/Conv2D" + input: "depth_net/disp4/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/disp4/Sigmoid" + op: "Sigmoid" + input: "depth_prediction/depth_net/disp4/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/mul/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 10.0 + } + } + } +} +node { + name: "depth_prediction/depth_net/mul" + op: "Mul" + input: "depth_prediction/depth_net/mul/x" + input: "depth_prediction/depth_net/disp4/Sigmoid" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/add/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.009999999776482582 + } + } + } +} +node { + name: "depth_prediction/depth_net/add" + op: "Add" + input: "depth_prediction/depth_net/mul" + input: "depth_prediction/depth_net/add/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/ResizeBilinear/size" + 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\000h\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/ResizeBilinear" + op: "ResizeBilinear" + input: "depth_prediction/depth_net/add" + input: "depth_prediction/depth_net/ResizeBilinear/size" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "align_corners" + value { + b: false + } + } +} +node { + name: "depth_net/upcnv3/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000@\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "depth_net/upcnv3/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + 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.0589255653321743 + } + } + } +} +node { + name: "depth_net/upcnv3/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + 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.0589255653321743 + } + } + } +} +node { + name: "depth_net/upcnv3/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/upcnv3/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 953 + } + } +} +node { + name: "depth_net/upcnv3/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/upcnv3/weights/Initializer/random_uniform/max" + input: "depth_net/upcnv3/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/upcnv3/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/upcnv3/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/upcnv3/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/upcnv3/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/upcnv3/weights/Initializer/random_uniform/mul" + input: "depth_net/upcnv3/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/upcnv3/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv3/weights/Assign" + op: "Assign" + input: "depth_net/upcnv3/weights" + input: "depth_net/upcnv3/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv3/weights/read" + op: "Identity" + input: "depth_net/upcnv3/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv3/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + 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: "depth_prediction/depth_net/upcnv3/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/upcnv3/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv3/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/upcnv3/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/upcnv3/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/upcnv3/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 64 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv3/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv3/biases/Assign" + op: "Assign" + input: "depth_net/upcnv3/biases" + input: "depth_net/upcnv3/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv3/biases/read" + op: "Identity" + input: "depth_net/upcnv3/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv3/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv3/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: "depth_prediction/depth_net/upcnv3/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: "depth_prediction/depth_net/upcnv3/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: "depth_prediction/depth_net/upcnv3/strided_slice" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv3/Shape" + input: "depth_prediction/depth_net/upcnv3/strided_slice/stack" + input: "depth_prediction/depth_net/upcnv3/strided_slice/stack_1" + input: "depth_prediction/depth_net/upcnv3/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: "depth_prediction/depth_net/upcnv3/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: "depth_prediction/depth_net/upcnv3/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: "depth_prediction/depth_net/upcnv3/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: "depth_prediction/depth_net/upcnv3/strided_slice_1" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv3/Shape" + input: "depth_prediction/depth_net/upcnv3/strided_slice_1/stack" + input: "depth_prediction/depth_net/upcnv3/strided_slice_1/stack_1" + input: "depth_prediction/depth_net/upcnv3/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: "depth_prediction/depth_net/upcnv3/strided_slice_2/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv3/strided_slice_2/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv3/strided_slice_2/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv3/strided_slice_2" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv3/Shape" + input: "depth_prediction/depth_net/upcnv3/strided_slice_2/stack" + input: "depth_prediction/depth_net/upcnv3/strided_slice_2/stack_1" + input: "depth_prediction/depth_net/upcnv3/strided_slice_2/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: "depth_prediction/depth_net/upcnv3/mul/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: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv3/mul" + op: "Mul" + input: "depth_prediction/depth_net/upcnv3/strided_slice_1" + input: "depth_prediction/depth_net/upcnv3/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv3/mul_1/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: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv3/mul_1" + op: "Mul" + input: "depth_prediction/depth_net/upcnv3/strided_slice_2" + input: "depth_prediction/depth_net/upcnv3/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv3/stack/3" + 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: 64 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv3/stack" + op: "Pack" + input: "depth_prediction/depth_net/upcnv3/strided_slice" + input: "depth_prediction/depth_net/upcnv3/mul" + input: "depth_prediction/depth_net/upcnv3/mul_1" + input: "depth_prediction/depth_net/upcnv3/stack/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "depth_prediction/depth_net/upcnv3/conv2d_transpose" + op: "Conv2DBackpropInput" + input: "depth_prediction/depth_net/upcnv3/stack" + input: "depth_net/upcnv3/weights/read" + input: "depth_prediction/depth_net/icnv4/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/upcnv3/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/upcnv3/conv2d_transpose" + input: "depth_net/upcnv3/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/upcnv3/Relu" + op: "Relu" + input: "depth_prediction/depth_net/upcnv3/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/concat_4/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: 3 + } + } + } +} +node { + name: "depth_prediction/depth_net/concat_4" + op: "ConcatV2" + input: "depth_prediction/depth_net/upcnv3/Relu" + input: "depth_prediction/depth_net/cnv2b/Relu" + input: "depth_prediction/depth_net/ResizeBilinear" + input: "depth_prediction/depth_net/concat_4/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 129 + } + } + } + } + } +} +node { + name: "depth_net/icnv3/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\201\000\000\000@\000\000\000" + } + } + } +} +node { + name: "depth_net/icnv3/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + 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.05877270922064781 + } + } + } +} +node { + name: "depth_net/icnv3/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + 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.05877270922064781 + } + } + } +} +node { + name: "depth_net/icnv3/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/icnv3/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 994 + } + } +} +node { + name: "depth_net/icnv3/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/icnv3/weights/Initializer/random_uniform/max" + input: "depth_net/icnv3/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/icnv3/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/icnv3/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/icnv3/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/icnv3/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/icnv3/weights/Initializer/random_uniform/mul" + input: "depth_net/icnv3/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/icnv3/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv3/weights/Assign" + op: "Assign" + input: "depth_net/icnv3/weights" + input: "depth_net/icnv3/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv3/weights/read" + op: "Identity" + input: "depth_net/icnv3/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv3/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + 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: "depth_prediction/depth_net/icnv3/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/icnv3/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv3/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/icnv3/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/icnv3/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/icnv3/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 64 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv3/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv3/biases/Assign" + op: "Assign" + input: "depth_net/icnv3/biases" + input: "depth_net/icnv3/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv3/biases/read" + op: "Identity" + input: "depth_net/icnv3/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv3/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv3/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/concat_4" + input: "depth_net/icnv3/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/icnv3/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/icnv3/Conv2D" + input: "depth_net/icnv3/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/icnv3/Relu" + op: "Relu" + input: "depth_prediction/depth_net/icnv3/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/disp3/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000@\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_net/disp3/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + 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.10127393901348114 + } + } + } +} +node { + name: "depth_net/disp3/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + 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.10127393901348114 + } + } + } +} +node { + name: "depth_net/disp3/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/disp3/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 1015 + } + } +} +node { + name: "depth_net/disp3/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/disp3/weights/Initializer/random_uniform/max" + input: "depth_net/disp3/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/disp3/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/disp3/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/disp3/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp3/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/disp3/weights/Initializer/random_uniform/mul" + input: "depth_net/disp3/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp3/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp3/weights/Assign" + op: "Assign" + input: "depth_net/disp3/weights" + input: "depth_net/disp3/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp3/weights/read" + op: "Identity" + input: "depth_net/disp3/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/disp3/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + 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: "depth_prediction/depth_net/disp3/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/disp3/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/disp3/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/disp3/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/disp3/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/disp3/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/disp3/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp3/biases/Assign" + op: "Assign" + input: "depth_net/disp3/biases" + input: "depth_net/disp3/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp3/biases/read" + op: "Identity" + input: "depth_net/disp3/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/disp3/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/disp3/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/icnv3/Relu" + input: "depth_net/disp3/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/disp3/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/disp3/Conv2D" + input: "depth_net/disp3/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/disp3/Sigmoid" + op: "Sigmoid" + input: "depth_prediction/depth_net/disp3/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/mul_1/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 10.0 + } + } + } +} +node { + name: "depth_prediction/depth_net/mul_1" + op: "Mul" + input: "depth_prediction/depth_net/mul_1/x" + input: "depth_prediction/depth_net/disp3/Sigmoid" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/add_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.009999999776482582 + } + } + } +} +node { + name: "depth_prediction/depth_net/add_1" + op: "Add" + input: "depth_prediction/depth_net/mul_1" + input: "depth_prediction/depth_net/add_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/ResizeBilinear_1/size" + 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\320\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/ResizeBilinear_1" + op: "ResizeBilinear" + input: "depth_prediction/depth_net/add_1" + input: "depth_prediction/depth_net/ResizeBilinear_1/size" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "align_corners" + value { + b: false + } + } +} +node { + name: "depth_net/upcnv2/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000 \000\000\000@\000\000\000" + } + } + } +} +node { + name: "depth_net/upcnv2/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + 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.0833333358168602 + } + } + } +} +node { + name: "depth_net/upcnv2/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + 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.0833333358168602 + } + } + } +} +node { + name: "depth_net/upcnv2/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/upcnv2/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 1042 + } + } +} +node { + name: "depth_net/upcnv2/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/upcnv2/weights/Initializer/random_uniform/max" + input: "depth_net/upcnv2/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/upcnv2/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/upcnv2/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/upcnv2/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/upcnv2/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/upcnv2/weights/Initializer/random_uniform/mul" + input: "depth_net/upcnv2/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/upcnv2/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv2/weights/Assign" + op: "Assign" + input: "depth_net/upcnv2/weights" + input: "depth_net/upcnv2/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv2/weights/read" + op: "Identity" + input: "depth_net/upcnv2/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv2/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + 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: "depth_prediction/depth_net/upcnv2/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/upcnv2/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv2/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/upcnv2/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/upcnv2/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/upcnv2/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 32 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv2/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv2/biases/Assign" + op: "Assign" + input: "depth_net/upcnv2/biases" + input: "depth_net/upcnv2/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv2/biases/read" + op: "Identity" + input: "depth_net/upcnv2/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv2/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000@\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv2/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: "depth_prediction/depth_net/upcnv2/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: "depth_prediction/depth_net/upcnv2/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: "depth_prediction/depth_net/upcnv2/strided_slice" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv2/Shape" + input: "depth_prediction/depth_net/upcnv2/strided_slice/stack" + input: "depth_prediction/depth_net/upcnv2/strided_slice/stack_1" + input: "depth_prediction/depth_net/upcnv2/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: "depth_prediction/depth_net/upcnv2/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: "depth_prediction/depth_net/upcnv2/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: "depth_prediction/depth_net/upcnv2/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: "depth_prediction/depth_net/upcnv2/strided_slice_1" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv2/Shape" + input: "depth_prediction/depth_net/upcnv2/strided_slice_1/stack" + input: "depth_prediction/depth_net/upcnv2/strided_slice_1/stack_1" + input: "depth_prediction/depth_net/upcnv2/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: "depth_prediction/depth_net/upcnv2/strided_slice_2/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv2/strided_slice_2/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv2/strided_slice_2/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv2/strided_slice_2" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv2/Shape" + input: "depth_prediction/depth_net/upcnv2/strided_slice_2/stack" + input: "depth_prediction/depth_net/upcnv2/strided_slice_2/stack_1" + input: "depth_prediction/depth_net/upcnv2/strided_slice_2/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: "depth_prediction/depth_net/upcnv2/mul/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: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv2/mul" + op: "Mul" + input: "depth_prediction/depth_net/upcnv2/strided_slice_1" + input: "depth_prediction/depth_net/upcnv2/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv2/mul_1/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: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv2/mul_1" + op: "Mul" + input: "depth_prediction/depth_net/upcnv2/strided_slice_2" + input: "depth_prediction/depth_net/upcnv2/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv2/stack/3" + 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: 32 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv2/stack" + op: "Pack" + input: "depth_prediction/depth_net/upcnv2/strided_slice" + input: "depth_prediction/depth_net/upcnv2/mul" + input: "depth_prediction/depth_net/upcnv2/mul_1" + input: "depth_prediction/depth_net/upcnv2/stack/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "depth_prediction/depth_net/upcnv2/conv2d_transpose" + op: "Conv2DBackpropInput" + input: "depth_prediction/depth_net/upcnv2/stack" + input: "depth_net/upcnv2/weights/read" + input: "depth_prediction/depth_net/icnv3/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/upcnv2/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/upcnv2/conv2d_transpose" + input: "depth_net/upcnv2/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/upcnv2/Relu" + op: "Relu" + input: "depth_prediction/depth_net/upcnv2/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/concat_5/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: 3 + } + } + } +} +node { + name: "depth_prediction/depth_net/concat_5" + op: "ConcatV2" + input: "depth_prediction/depth_net/upcnv2/Relu" + input: "depth_prediction/depth_net/cnv1b/Relu" + input: "depth_prediction/depth_net/ResizeBilinear_1" + input: "depth_prediction/depth_net/concat_5/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 65 + } + } + } + } + } +} +node { + name: "depth_net/icnv2/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000A\000\000\000 \000\000\000" + } + } + } +} +node { + name: "depth_net/icnv2/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + 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.08290266990661621 + } + } + } +} +node { + name: "depth_net/icnv2/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + 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.08290266990661621 + } + } + } +} +node { + name: "depth_net/icnv2/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/icnv2/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 1083 + } + } +} +node { + name: "depth_net/icnv2/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/icnv2/weights/Initializer/random_uniform/max" + input: "depth_net/icnv2/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/icnv2/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/icnv2/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/icnv2/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/icnv2/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/icnv2/weights/Initializer/random_uniform/mul" + input: "depth_net/icnv2/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/icnv2/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv2/weights/Assign" + op: "Assign" + input: "depth_net/icnv2/weights" + input: "depth_net/icnv2/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv2/weights/read" + op: "Identity" + input: "depth_net/icnv2/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv2/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + 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: "depth_prediction/depth_net/icnv2/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/icnv2/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv2/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/icnv2/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/icnv2/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/icnv2/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 32 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv2/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv2/biases/Assign" + op: "Assign" + input: "depth_net/icnv2/biases" + input: "depth_net/icnv2/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv2/biases/read" + op: "Identity" + input: "depth_net/icnv2/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv2/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv2/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/concat_5" + input: "depth_net/icnv2/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/icnv2/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/icnv2/Conv2D" + input: "depth_net/icnv2/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/icnv2/Relu" + op: "Relu" + input: "depth_prediction/depth_net/icnv2/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/disp2/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000 \000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_net/disp2/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + 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.14213381707668304 + } + } + } +} +node { + name: "depth_net/disp2/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + 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.14213381707668304 + } + } + } +} +node { + name: "depth_net/disp2/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/disp2/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 1104 + } + } +} +node { + name: "depth_net/disp2/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/disp2/weights/Initializer/random_uniform/max" + input: "depth_net/disp2/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/disp2/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/disp2/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/disp2/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp2/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/disp2/weights/Initializer/random_uniform/mul" + input: "depth_net/disp2/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp2/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp2/weights/Assign" + op: "Assign" + input: "depth_net/disp2/weights" + input: "depth_net/disp2/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp2/weights/read" + op: "Identity" + input: "depth_net/disp2/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/disp2/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + 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: "depth_prediction/depth_net/disp2/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/disp2/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/disp2/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/disp2/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/disp2/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/disp2/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/disp2/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp2/biases/Assign" + op: "Assign" + input: "depth_net/disp2/biases" + input: "depth_net/disp2/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp2/biases/read" + op: "Identity" + input: "depth_net/disp2/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/disp2/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/disp2/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/icnv2/Relu" + input: "depth_net/disp2/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/disp2/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/disp2/Conv2D" + input: "depth_net/disp2/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/disp2/Sigmoid" + op: "Sigmoid" + input: "depth_prediction/depth_net/disp2/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/mul_2/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 10.0 + } + } + } +} +node { + name: "depth_prediction/depth_net/mul_2" + op: "Mul" + input: "depth_prediction/depth_net/mul_2/x" + input: "depth_prediction/depth_net/disp2/Sigmoid" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/add_2/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.009999999776482582 + } + } + } +} +node { + name: "depth_prediction/depth_net/add_2" + op: "Add" + input: "depth_prediction/depth_net/mul_2" + input: "depth_prediction/depth_net/add_2/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/ResizeBilinear_2/size" + 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: "\200\000\000\000\240\001\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/ResizeBilinear_2" + op: "ResizeBilinear" + input: "depth_prediction/depth_net/add_2" + input: "depth_prediction/depth_net/ResizeBilinear_2/size" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "align_corners" + value { + b: false + } + } +} +node { + name: "depth_net/upcnv1/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\020\000\000\000 \000\000\000" + } + } + } +} +node { + name: "depth_net/upcnv1/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + 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.1178511306643486 + } + } + } +} +node { + name: "depth_net/upcnv1/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + 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.1178511306643486 + } + } + } +} +node { + name: "depth_net/upcnv1/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/upcnv1/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 1131 + } + } +} +node { + name: "depth_net/upcnv1/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/upcnv1/weights/Initializer/random_uniform/max" + input: "depth_net/upcnv1/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/upcnv1/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/upcnv1/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/upcnv1/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/upcnv1/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/upcnv1/weights/Initializer/random_uniform/mul" + input: "depth_net/upcnv1/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/upcnv1/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv1/weights/Assign" + op: "Assign" + input: "depth_net/upcnv1/weights" + input: "depth_net/upcnv1/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv1/weights/read" + op: "Identity" + input: "depth_net/upcnv1/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv1/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + 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: "depth_prediction/depth_net/upcnv1/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/upcnv1/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv1/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/upcnv1/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/upcnv1/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/upcnv1/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 16 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv1/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 16 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv1/biases/Assign" + op: "Assign" + input: "depth_net/upcnv1/biases" + input: "depth_net/upcnv1/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv1/biases/read" + op: "Identity" + input: "depth_net/upcnv1/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv1/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000 \000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv1/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: "depth_prediction/depth_net/upcnv1/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: "depth_prediction/depth_net/upcnv1/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: "depth_prediction/depth_net/upcnv1/strided_slice" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv1/Shape" + input: "depth_prediction/depth_net/upcnv1/strided_slice/stack" + input: "depth_prediction/depth_net/upcnv1/strided_slice/stack_1" + input: "depth_prediction/depth_net/upcnv1/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: "depth_prediction/depth_net/upcnv1/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: "depth_prediction/depth_net/upcnv1/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: "depth_prediction/depth_net/upcnv1/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: "depth_prediction/depth_net/upcnv1/strided_slice_1" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv1/Shape" + input: "depth_prediction/depth_net/upcnv1/strided_slice_1/stack" + input: "depth_prediction/depth_net/upcnv1/strided_slice_1/stack_1" + input: "depth_prediction/depth_net/upcnv1/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: "depth_prediction/depth_net/upcnv1/strided_slice_2/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv1/strided_slice_2/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv1/strided_slice_2/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv1/strided_slice_2" + op: "StridedSlice" + input: "depth_prediction/depth_net/upcnv1/Shape" + input: "depth_prediction/depth_net/upcnv1/strided_slice_2/stack" + input: "depth_prediction/depth_net/upcnv1/strided_slice_2/stack_1" + input: "depth_prediction/depth_net/upcnv1/strided_slice_2/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: "depth_prediction/depth_net/upcnv1/mul/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: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv1/mul" + op: "Mul" + input: "depth_prediction/depth_net/upcnv1/strided_slice_1" + input: "depth_prediction/depth_net/upcnv1/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv1/mul_1/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: 2 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv1/mul_1" + op: "Mul" + input: "depth_prediction/depth_net/upcnv1/strided_slice_2" + input: "depth_prediction/depth_net/upcnv1/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv1/stack/3" + 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: 16 + } + } + } +} +node { + name: "depth_prediction/depth_net/upcnv1/stack" + op: "Pack" + input: "depth_prediction/depth_net/upcnv1/strided_slice" + input: "depth_prediction/depth_net/upcnv1/mul" + input: "depth_prediction/depth_net/upcnv1/mul_1" + input: "depth_prediction/depth_net/upcnv1/stack/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "depth_prediction/depth_net/upcnv1/conv2d_transpose" + op: "Conv2DBackpropInput" + input: "depth_prediction/depth_net/upcnv1/stack" + input: "depth_net/upcnv1/weights/read" + input: "depth_prediction/depth_net/icnv2/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/upcnv1/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/upcnv1/conv2d_transpose" + input: "depth_net/upcnv1/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/upcnv1/Relu" + op: "Relu" + input: "depth_prediction/depth_net/upcnv1/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/concat_6/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: 3 + } + } + } +} +node { + name: "depth_prediction/depth_net/concat_6" + op: "ConcatV2" + input: "depth_prediction/depth_net/upcnv1/Relu" + input: "depth_prediction/depth_net/ResizeBilinear_2" + input: "depth_prediction/depth_net/concat_6/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 17 + } + } + } + } + } +} +node { + name: "depth_net/icnv1/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\021\000\000\000\020\000\000\000" + } + } + } +} +node { + name: "depth_net/icnv1/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + 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.14213381707668304 + } + } + } +} +node { + name: "depth_net/icnv1/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + 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.14213381707668304 + } + } + } +} +node { + name: "depth_net/icnv1/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/icnv1/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 1172 + } + } +} +node { + name: "depth_net/icnv1/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/icnv1/weights/Initializer/random_uniform/max" + input: "depth_net/icnv1/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/icnv1/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/icnv1/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/icnv1/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "depth_net/icnv1/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/icnv1/weights/Initializer/random_uniform/mul" + input: "depth_net/icnv1/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "depth_net/icnv1/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv1/weights/Assign" + op: "Assign" + input: "depth_net/icnv1/weights" + input: "depth_net/icnv1/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv1/weights/read" + op: "Identity" + input: "depth_net/icnv1/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv1/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + 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: "depth_prediction/depth_net/icnv1/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/icnv1/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv1/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/icnv1/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/icnv1/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/icnv1/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 16 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv1/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 16 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv1/biases/Assign" + op: "Assign" + input: "depth_net/icnv1/biases" + input: "depth_net/icnv1/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv1/biases/read" + op: "Identity" + input: "depth_net/icnv1/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv1/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/icnv1/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/concat_6" + input: "depth_net/icnv1/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/icnv1/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/icnv1/Conv2D" + input: "depth_net/icnv1/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/icnv1/Relu" + op: "Relu" + input: "depth_prediction/depth_net/icnv1/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "depth_net/disp1/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\020\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_net/disp1/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + 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.1980295032262802 + } + } + } +} +node { + name: "depth_net/disp1/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + 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.1980295032262802 + } + } + } +} +node { + name: "depth_net/disp1/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "depth_net/disp1/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 1193 + } + } +} +node { + name: "depth_net/disp1/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "depth_net/disp1/weights/Initializer/random_uniform/max" + input: "depth_net/disp1/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/disp1/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "depth_net/disp1/weights/Initializer/random_uniform/RandomUniform" + input: "depth_net/disp1/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp1/weights/Initializer/random_uniform" + op: "Add" + input: "depth_net/disp1/weights/Initializer/random_uniform/mul" + input: "depth_net/disp1/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp1/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp1/weights/Assign" + op: "Assign" + input: "depth_net/disp1/weights" + input: "depth_net/disp1/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp1/weights/read" + op: "Identity" + input: "depth_net/disp1/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/disp1/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + 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: "depth_prediction/depth_net/disp1/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "depth_net/disp1/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_prediction/depth_net/disp1/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "depth_prediction/depth_net/disp1/kernel/Regularizer/l2_regularizer/scale" + input: "depth_prediction/depth_net/disp1/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/disp1/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/disp1/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp1/biases/Assign" + op: "Assign" + input: "depth_net/disp1/biases" + input: "depth_net/disp1/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp1/biases/read" + op: "Identity" + input: "depth_net/disp1/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/disp1/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_prediction/depth_net/disp1/Conv2D" + op: "Conv2D" + input: "depth_prediction/depth_net/icnv1/Relu" + input: "depth_net/disp1/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "depth_prediction/depth_net/disp1/BiasAdd" + op: "BiasAdd" + input: "depth_prediction/depth_net/disp1/Conv2D" + input: "depth_net/disp1/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "depth_prediction/depth_net/disp1/Sigmoid" + op: "Sigmoid" + input: "depth_prediction/depth_net/disp1/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/mul_3/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 10.0 + } + } + } +} +node { + name: "depth_prediction/depth_net/mul_3" + op: "Mul" + input: "depth_prediction/depth_net/mul_3/x" + input: "depth_prediction/depth_net/disp1/Sigmoid" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/depth_net/add_3/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.009999999776482582 + } + } + } +} +node { + name: "depth_prediction/depth_net/add_3" + op: "Add" + input: "depth_prediction/depth_net/mul_3" + input: "depth_prediction/depth_net/add_3/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/truediv/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "depth_prediction/truediv" + op: "RealDiv" + input: "depth_prediction/truediv/x" + input: "depth_prediction/depth_net/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/truediv_1/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "depth_prediction/truediv_1" + op: "RealDiv" + input: "depth_prediction/truediv_1/x" + input: "depth_prediction/depth_net/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/truediv_2/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "depth_prediction/truediv_2" + op: "RealDiv" + input: "depth_prediction/truediv_2/x" + input: "depth_prediction/depth_net/add_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_prediction/truediv_3/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "depth_prediction/truediv_3" + op: "RealDiv" + input: "depth_prediction/truediv_3/x" + input: "depth_prediction/depth_net/add" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/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: 3 + } + } + } +} +node { + name: "pose_and_explainability_prediction/concat" + op: "ConcatV2" + input: "data_loading/sub_4" + input: "data_loading/sub_5" + input: "pose_and_explainability_prediction/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 9 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv1/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\007\000\000\000\007\000\000\000\t\000\000\000\020\000\000\000" + } + } + } +} +node { + name: "pose_exp_net/cnv1/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + 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.06998541951179504 + } + } + } +} +node { + name: "pose_exp_net/cnv1/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + 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.06998541951179504 + } + } + } +} +node { + name: "pose_exp_net/cnv1/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "pose_exp_net/cnv1/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 1228 + } + } +} +node { + name: "pose_exp_net/cnv1/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "pose_exp_net/cnv1/weights/Initializer/random_uniform/max" + input: "pose_exp_net/cnv1/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_exp_net/cnv1/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "pose_exp_net/cnv1/weights/Initializer/random_uniform/RandomUniform" + input: "pose_exp_net/cnv1/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv1/weights/Initializer/random_uniform" + op: "Add" + input: "pose_exp_net/cnv1/weights/Initializer/random_uniform/mul" + input: "pose_exp_net/cnv1/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv1/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv1/weights/Assign" + op: "Assign" + input: "pose_exp_net/cnv1/weights" + input: "pose_exp_net/cnv1/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv1/weights/read" + op: "Identity" + input: "pose_exp_net/cnv1/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv1/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + 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: "pose_and_explainability_prediction/pose_exp_net/cnv1/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "pose_exp_net/cnv1/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv1/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "pose_and_explainability_prediction/pose_exp_net/cnv1/kernel/Regularizer/l2_regularizer/scale" + input: "pose_and_explainability_prediction/pose_exp_net/cnv1/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_exp_net/cnv1/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 16 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/cnv1/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 16 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv1/biases/Assign" + op: "Assign" + input: "pose_exp_net/cnv1/biases" + input: "pose_exp_net/cnv1/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv1/biases/read" + op: "Identity" + input: "pose_exp_net/cnv1/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv1/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv1/Conv2D" + op: "Conv2D" + input: "pose_and_explainability_prediction/concat" + input: "pose_exp_net/cnv1/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv1/BiasAdd" + op: "BiasAdd" + input: "pose_and_explainability_prediction/pose_exp_net/cnv1/Conv2D" + input: "pose_exp_net/cnv1/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv1/Relu" + op: "Relu" + input: "pose_and_explainability_prediction/pose_exp_net/cnv1/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv2/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\005\000\000\000\005\000\000\000\020\000\000\000 \000\000\000" + } + } + } +} +node { + name: "pose_exp_net/cnv2/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + 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.0707106813788414 + } + } + } +} +node { + name: "pose_exp_net/cnv2/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + 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.0707106813788414 + } + } + } +} +node { + name: "pose_exp_net/cnv2/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "pose_exp_net/cnv2/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 1249 + } + } +} +node { + name: "pose_exp_net/cnv2/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "pose_exp_net/cnv2/weights/Initializer/random_uniform/max" + input: "pose_exp_net/cnv2/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_exp_net/cnv2/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "pose_exp_net/cnv2/weights/Initializer/random_uniform/RandomUniform" + input: "pose_exp_net/cnv2/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv2/weights/Initializer/random_uniform" + op: "Add" + input: "pose_exp_net/cnv2/weights/Initializer/random_uniform/mul" + input: "pose_exp_net/cnv2/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv2/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv2/weights/Assign" + op: "Assign" + input: "pose_exp_net/cnv2/weights" + input: "pose_exp_net/cnv2/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv2/weights/read" + op: "Identity" + input: "pose_exp_net/cnv2/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv2/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + 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: "pose_and_explainability_prediction/pose_exp_net/cnv2/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "pose_exp_net/cnv2/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv2/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "pose_and_explainability_prediction/pose_exp_net/cnv2/kernel/Regularizer/l2_regularizer/scale" + input: "pose_and_explainability_prediction/pose_exp_net/cnv2/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_exp_net/cnv2/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 32 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/cnv2/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv2/biases/Assign" + op: "Assign" + input: "pose_exp_net/cnv2/biases" + input: "pose_exp_net/cnv2/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv2/biases/read" + op: "Identity" + input: "pose_exp_net/cnv2/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv2/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D" + op: "Conv2D" + input: "pose_and_explainability_prediction/pose_exp_net/cnv1/Relu" + input: "pose_exp_net/cnv2/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv2/BiasAdd" + op: "BiasAdd" + input: "pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D" + input: "pose_exp_net/cnv2/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv2/Relu" + op: "Relu" + input: "pose_and_explainability_prediction/pose_exp_net/cnv2/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv3/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000 \000\000\000@\000\000\000" + } + } + } +} +node { + name: "pose_exp_net/cnv3/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + 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.0833333358168602 + } + } + } +} +node { + name: "pose_exp_net/cnv3/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + 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.0833333358168602 + } + } + } +} +node { + name: "pose_exp_net/cnv3/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "pose_exp_net/cnv3/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 1270 + } + } +} +node { + name: "pose_exp_net/cnv3/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "pose_exp_net/cnv3/weights/Initializer/random_uniform/max" + input: "pose_exp_net/cnv3/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_exp_net/cnv3/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "pose_exp_net/cnv3/weights/Initializer/random_uniform/RandomUniform" + input: "pose_exp_net/cnv3/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv3/weights/Initializer/random_uniform" + op: "Add" + input: "pose_exp_net/cnv3/weights/Initializer/random_uniform/mul" + input: "pose_exp_net/cnv3/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv3/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv3/weights/Assign" + op: "Assign" + input: "pose_exp_net/cnv3/weights" + input: "pose_exp_net/cnv3/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv3/weights/read" + op: "Identity" + input: "pose_exp_net/cnv3/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv3/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + 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: "pose_and_explainability_prediction/pose_exp_net/cnv3/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "pose_exp_net/cnv3/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv3/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "pose_and_explainability_prediction/pose_exp_net/cnv3/kernel/Regularizer/l2_regularizer/scale" + input: "pose_and_explainability_prediction/pose_exp_net/cnv3/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_exp_net/cnv3/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 64 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/cnv3/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv3/biases/Assign" + op: "Assign" + input: "pose_exp_net/cnv3/biases" + input: "pose_exp_net/cnv3/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv3/biases/read" + op: "Identity" + input: "pose_exp_net/cnv3/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv3/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D" + op: "Conv2D" + input: "pose_and_explainability_prediction/pose_exp_net/cnv2/Relu" + input: "pose_exp_net/cnv3/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv3/BiasAdd" + op: "BiasAdd" + input: "pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D" + input: "pose_exp_net/cnv3/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv3/Relu" + op: "Relu" + input: "pose_and_explainability_prediction/pose_exp_net/cnv3/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv4/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000@\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "pose_exp_net/cnv4/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + 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.0589255653321743 + } + } + } +} +node { + name: "pose_exp_net/cnv4/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + 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.0589255653321743 + } + } + } +} +node { + name: "pose_exp_net/cnv4/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "pose_exp_net/cnv4/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 1291 + } + } +} +node { + name: "pose_exp_net/cnv4/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "pose_exp_net/cnv4/weights/Initializer/random_uniform/max" + input: "pose_exp_net/cnv4/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_exp_net/cnv4/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "pose_exp_net/cnv4/weights/Initializer/random_uniform/RandomUniform" + input: "pose_exp_net/cnv4/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv4/weights/Initializer/random_uniform" + op: "Add" + input: "pose_exp_net/cnv4/weights/Initializer/random_uniform/mul" + input: "pose_exp_net/cnv4/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv4/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv4/weights/Assign" + op: "Assign" + input: "pose_exp_net/cnv4/weights" + input: "pose_exp_net/cnv4/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv4/weights/read" + op: "Identity" + input: "pose_exp_net/cnv4/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv4/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + 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: "pose_and_explainability_prediction/pose_exp_net/cnv4/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "pose_exp_net/cnv4/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv4/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "pose_and_explainability_prediction/pose_exp_net/cnv4/kernel/Regularizer/l2_regularizer/scale" + input: "pose_and_explainability_prediction/pose_exp_net/cnv4/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_exp_net/cnv4/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 128 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/cnv4/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv4/biases/Assign" + op: "Assign" + input: "pose_exp_net/cnv4/biases" + input: "pose_exp_net/cnv4/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv4/biases/read" + op: "Identity" + input: "pose_exp_net/cnv4/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv4/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D" + op: "Conv2D" + input: "pose_and_explainability_prediction/pose_exp_net/cnv3/Relu" + input: "pose_exp_net/cnv4/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv4/BiasAdd" + op: "BiasAdd" + input: "pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D" + input: "pose_exp_net/cnv4/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv4/Relu" + op: "Relu" + input: "pose_and_explainability_prediction/pose_exp_net/cnv4/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv5/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\000\001\000\000" + } + } + } +} +node { + name: "pose_exp_net/cnv5/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + 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.0416666679084301 + } + } + } +} +node { + name: "pose_exp_net/cnv5/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + 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.0416666679084301 + } + } + } +} +node { + name: "pose_exp_net/cnv5/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "pose_exp_net/cnv5/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 1312 + } + } +} +node { + name: "pose_exp_net/cnv5/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "pose_exp_net/cnv5/weights/Initializer/random_uniform/max" + input: "pose_exp_net/cnv5/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_exp_net/cnv5/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "pose_exp_net/cnv5/weights/Initializer/random_uniform/RandomUniform" + input: "pose_exp_net/cnv5/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv5/weights/Initializer/random_uniform" + op: "Add" + input: "pose_exp_net/cnv5/weights/Initializer/random_uniform/mul" + input: "pose_exp_net/cnv5/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv5/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv5/weights/Assign" + op: "Assign" + input: "pose_exp_net/cnv5/weights" + input: "pose_exp_net/cnv5/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv5/weights/read" + op: "Identity" + input: "pose_exp_net/cnv5/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv5/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + 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: "pose_and_explainability_prediction/pose_exp_net/cnv5/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "pose_exp_net/cnv5/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv5/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "pose_and_explainability_prediction/pose_exp_net/cnv5/kernel/Regularizer/l2_regularizer/scale" + input: "pose_and_explainability_prediction/pose_exp_net/cnv5/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_exp_net/cnv5/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/cnv5/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv5/biases/Assign" + op: "Assign" + input: "pose_exp_net/cnv5/biases" + input: "pose_exp_net/cnv5/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv5/biases/read" + op: "Identity" + input: "pose_exp_net/cnv5/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv5/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D" + op: "Conv2D" + input: "pose_and_explainability_prediction/pose_exp_net/cnv4/Relu" + input: "pose_exp_net/cnv5/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv5/BiasAdd" + op: "BiasAdd" + input: "pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D" + input: "pose_exp_net/cnv5/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/cnv5/Relu" + op: "Relu" + input: "pose_and_explainability_prediction/pose_exp_net/cnv5/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\001\000\000" + } + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + 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.03608439117670059 + } + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + 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.03608439117670059 + } + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "pose_exp_net/pose/cnv6/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 1333 + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "pose_exp_net/pose/cnv6/weights/Initializer/random_uniform/max" + input: "pose_exp_net/pose/cnv6/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "pose_exp_net/pose/cnv6/weights/Initializer/random_uniform/RandomUniform" + input: "pose_exp_net/pose/cnv6/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights/Initializer/random_uniform" + op: "Add" + input: "pose_exp_net/pose/cnv6/weights/Initializer/random_uniform/mul" + input: "pose_exp_net/pose/cnv6/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights/Assign" + op: "Assign" + input: "pose_exp_net/pose/cnv6/weights" + input: "pose_exp_net/pose/cnv6/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights/read" + op: "Identity" + input: "pose_exp_net/pose/cnv6/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/cnv6/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + 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: "pose_and_explainability_prediction/pose_exp_net/pose/cnv6/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "pose_exp_net/pose/cnv6/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/cnv6/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "pose_and_explainability_prediction/pose_exp_net/pose/cnv6/kernel/Regularizer/l2_regularizer/scale" + input: "pose_and_explainability_prediction/pose_exp_net/pose/cnv6/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_exp_net/pose/cnv6/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/pose/cnv6/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/pose/cnv6/biases/Assign" + op: "Assign" + input: "pose_exp_net/pose/cnv6/biases" + input: "pose_exp_net/pose/cnv6/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/pose/cnv6/biases/read" + op: "Identity" + input: "pose_exp_net/pose/cnv6/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/cnv6/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D" + op: "Conv2D" + input: "pose_and_explainability_prediction/pose_exp_net/cnv5/Relu" + input: "pose_exp_net/pose/cnv6/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/cnv6/BiasAdd" + op: "BiasAdd" + input: "pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D" + input: "pose_exp_net/pose/cnv6/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Relu" + op: "Relu" + input: "pose_and_explainability_prediction/pose_exp_net/pose/cnv6/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\001\000\000" + } + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + 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.03608439117670059 + } + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + 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.03608439117670059 + } + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "pose_exp_net/pose/cnv7/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 1354 + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "pose_exp_net/pose/cnv7/weights/Initializer/random_uniform/max" + input: "pose_exp_net/pose/cnv7/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "pose_exp_net/pose/cnv7/weights/Initializer/random_uniform/RandomUniform" + input: "pose_exp_net/pose/cnv7/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights/Initializer/random_uniform" + op: "Add" + input: "pose_exp_net/pose/cnv7/weights/Initializer/random_uniform/mul" + input: "pose_exp_net/pose/cnv7/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights/Assign" + op: "Assign" + input: "pose_exp_net/pose/cnv7/weights" + input: "pose_exp_net/pose/cnv7/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights/read" + op: "Identity" + input: "pose_exp_net/pose/cnv7/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/cnv7/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + 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: "pose_and_explainability_prediction/pose_exp_net/pose/cnv7/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "pose_exp_net/pose/cnv7/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/cnv7/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "pose_and_explainability_prediction/pose_exp_net/pose/cnv7/kernel/Regularizer/l2_regularizer/scale" + input: "pose_and_explainability_prediction/pose_exp_net/pose/cnv7/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_exp_net/pose/cnv7/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/pose/cnv7/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/pose/cnv7/biases/Assign" + op: "Assign" + input: "pose_exp_net/pose/cnv7/biases" + input: "pose_exp_net/pose/cnv7/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/pose/cnv7/biases/read" + op: "Identity" + input: "pose_exp_net/pose/cnv7/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/cnv7/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D" + op: "Conv2D" + input: "pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Relu" + input: "pose_exp_net/pose/cnv7/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/cnv7/BiasAdd" + op: "BiasAdd" + input: "pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D" + input: "pose_exp_net/pose/cnv7/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Relu" + op: "Relu" + input: "pose_and_explainability_prediction/pose_exp_net/pose/cnv7/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/pred/weights/Initializer/random_uniform/shape" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\000\001\000\000\014\000\000\000" + } + } + } +} +node { + name: "pose_exp_net/pose/pred/weights/Initializer/random_uniform/min" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + 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.14962640404701233 + } + } + } +} +node { + name: "pose_exp_net/pose/pred/weights/Initializer/random_uniform/max" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + 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.14962640404701233 + } + } + } +} +node { + name: "pose_exp_net/pose/pred/weights/Initializer/random_uniform/RandomUniform" + op: "RandomUniform" + input: "pose_exp_net/pose/pred/weights/Initializer/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 8964 + } + } + attr { + key: "seed2" + value { + i: 1375 + } + } +} +node { + name: "pose_exp_net/pose/pred/weights/Initializer/random_uniform/sub" + op: "Sub" + input: "pose_exp_net/pose/pred/weights/Initializer/random_uniform/max" + input: "pose_exp_net/pose/pred/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_exp_net/pose/pred/weights/Initializer/random_uniform/mul" + op: "Mul" + input: "pose_exp_net/pose/pred/weights/Initializer/random_uniform/RandomUniform" + input: "pose_exp_net/pose/pred/weights/Initializer/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/pred/weights/Initializer/random_uniform" + op: "Add" + input: "pose_exp_net/pose/pred/weights/Initializer/random_uniform/mul" + input: "pose_exp_net/pose/pred/weights/Initializer/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/pred/weights" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/pose/pred/weights/Assign" + op: "Assign" + input: "pose_exp_net/pose/pred/weights" + input: "pose_exp_net/pose/pred/weights/Initializer/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/pose/pred/weights/read" + op: "Identity" + input: "pose_exp_net/pose/pred/weights" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/pred/kernel/Regularizer/l2_regularizer/scale" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + 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: "pose_and_explainability_prediction/pose_exp_net/pose/pred/kernel/Regularizer/l2_regularizer/L2Loss" + op: "L2Loss" + input: "pose_exp_net/pose/pred/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/pred/kernel/Regularizer/l2_regularizer" + op: "Mul" + input: "pose_and_explainability_prediction/pose_exp_net/pose/pred/kernel/Regularizer/l2_regularizer/scale" + input: "pose_and_explainability_prediction/pose_exp_net/pose/pred/kernel/Regularizer/l2_regularizer/L2Loss" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pose_exp_net/pose/pred/biases/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 12 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 12 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/pose/pred/biases" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 12 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 12 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/pose/pred/biases/Assign" + op: "Assign" + input: "pose_exp_net/pose/pred/biases" + input: "pose_exp_net/pose/pred/biases/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 12 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/pose/pred/biases/read" + op: "Identity" + input: "pose_exp_net/pose/pred/biases" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 12 + } + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/pred/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D" + op: "Conv2D" + input: "pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Relu" + input: "pose_exp_net/pose/pred/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 12 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/pred/BiasAdd" + op: "BiasAdd" + input: "pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D" + input: "pose_exp_net/pose/pred/biases/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 12 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/Mean/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/Mean" + op: "Mean" + input: "pose_and_explainability_prediction/pose_exp_net/pose/pred/BiasAdd" + input: "pose_and_explainability_prediction/pose_exp_net/pose/Mean/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 12 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\002\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/Reshape" + op: "Reshape" + input: "pose_and_explainability_prediction/pose_exp_net/pose/Mean" + input: "pose_and_explainability_prediction/pose_exp_net/pose/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: 4 + } + dim { + size: 2 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/mul/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.009999999776482582 + } + } + } +} +node { + name: "pose_and_explainability_prediction/pose_exp_net/pose/mul" + op: "Mul" + input: "pose_and_explainability_prediction/pose_exp_net/pose/mul/x" + input: "pose_and_explainability_prediction/pose_exp_net/pose/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "compute_loss/ResizeArea/size" + 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: "\200\000\000\000\240\001\000\000" + } + } + } +} +node { + name: "compute_loss/ResizeArea" + op: "ResizeArea" + input: "data_loading/sub_4" + input: "compute_loss/ResizeArea/size" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "align_corners" + value { + b: false + } + } +} +node { + name: "compute_loss/ResizeArea_1/size" + 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: "\200\000\000\000\240\001\000\000" + } + } + } +} +node { + name: "compute_loss/ResizeArea_1" + op: "ResizeArea" + input: "data_loading/sub_5" + input: "compute_loss/ResizeArea_1/size" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "align_corners" + value { + b: false + } + } +} +node { + name: "compute_loss/strided_slice/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice" + op: "StridedSlice" + input: "depth_prediction/depth_net/add_3" + input: "compute_loss/strided_slice/stack" + input: "compute_loss/strided_slice/stack_1" + input: "compute_loss/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_1/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_1/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\377\377\377\377\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_1/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_1" + op: "StridedSlice" + input: "depth_prediction/depth_net/add_3" + input: "compute_loss/strided_slice_1/stack" + input: "compute_loss/strided_slice_1/stack_1" + input: "compute_loss/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub" + op: "Sub" + input: "compute_loss/strided_slice" + input: "compute_loss/strided_slice_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_2/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_2/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_2/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_2" + op: "StridedSlice" + input: "depth_prediction/depth_net/add_3" + input: "compute_loss/strided_slice_2/stack" + input: "compute_loss/strided_slice_2/stack_1" + input: "compute_loss/strided_slice_2/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_3/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_3/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\377\377\377\377\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_3/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_3" + op: "StridedSlice" + input: "depth_prediction/depth_net/add_3" + input: "compute_loss/strided_slice_3/stack" + input: "compute_loss/strided_slice_3/stack_1" + input: "compute_loss/strided_slice_3/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_1" + op: "Sub" + input: "compute_loss/strided_slice_2" + input: "compute_loss/strided_slice_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_4/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_4/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_4/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_4" + op: "StridedSlice" + input: "compute_loss/sub_1" + input: "compute_loss/strided_slice_4/stack" + input: "compute_loss/strided_slice_4/stack_1" + input: "compute_loss/strided_slice_4/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_5/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_5/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\377\377\377\377\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_5/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_5" + op: "StridedSlice" + input: "compute_loss/sub_1" + input: "compute_loss/strided_slice_5/stack" + input: "compute_loss/strided_slice_5/stack_1" + input: "compute_loss/strided_slice_5/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_2" + op: "Sub" + input: "compute_loss/strided_slice_4" + input: "compute_loss/strided_slice_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_6/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_6/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_6/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_6" + op: "StridedSlice" + input: "compute_loss/sub_1" + input: "compute_loss/strided_slice_6/stack" + input: "compute_loss/strided_slice_6/stack_1" + input: "compute_loss/strided_slice_6/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 414 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_7/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_7/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\377\377\377\377\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_7/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_7" + op: "StridedSlice" + input: "compute_loss/sub_1" + input: "compute_loss/strided_slice_7/stack" + input: "compute_loss/strided_slice_7/stack_1" + input: "compute_loss/strided_slice_7/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 414 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_3" + op: "Sub" + input: "compute_loss/strided_slice_6" + input: "compute_loss/strided_slice_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 414 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_8/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_8/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_8/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_8" + op: "StridedSlice" + input: "compute_loss/sub" + input: "compute_loss/strided_slice_8/stack" + input: "compute_loss/strided_slice_8/stack_1" + input: "compute_loss/strided_slice_8/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 126 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_9/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_9/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\377\377\377\377\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_9/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_9" + op: "StridedSlice" + input: "compute_loss/sub" + input: "compute_loss/strided_slice_9/stack" + input: "compute_loss/strided_slice_9/stack_1" + input: "compute_loss/strided_slice_9/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 126 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_4" + op: "Sub" + input: "compute_loss/strided_slice_8" + input: "compute_loss/strided_slice_9" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 126 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_10/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_10/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_10/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_10" + op: "StridedSlice" + input: "compute_loss/sub" + input: "compute_loss/strided_slice_10/stack" + input: "compute_loss/strided_slice_10/stack_1" + input: "compute_loss/strided_slice_10/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_11/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_11/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\377\377\377\377\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_11/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_11" + op: "StridedSlice" + input: "compute_loss/sub" + input: "compute_loss/strided_slice_11/stack" + input: "compute_loss/strided_slice_11/stack_1" + input: "compute_loss/strided_slice_11/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_5" + op: "Sub" + input: "compute_loss/strided_slice_10" + input: "compute_loss/strided_slice_11" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Abs" + op: "Abs" + input: "compute_loss/sub_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 414 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean" + op: "Mean" + input: "compute_loss/Abs" + input: "compute_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: "compute_loss/Abs_1" + op: "Abs" + input: "compute_loss/sub_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_1" + op: "Mean" + input: "compute_loss/Abs_1" + input: "compute_loss/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "compute_loss/add" + op: "Add" + input: "compute_loss/Mean" + input: "compute_loss/Mean_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/Abs_2" + op: "Abs" + input: "compute_loss/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Const_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_2" + op: "Mean" + input: "compute_loss/Abs_2" + input: "compute_loss/Const_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "compute_loss/add_1" + op: "Add" + input: "compute_loss/add" + input: "compute_loss/Mean_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/Abs_3" + op: "Abs" + input: "compute_loss/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 126 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Const_3" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_3" + op: "Mean" + input: "compute_loss/Abs_3" + input: "compute_loss/Const_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "compute_loss/add_2" + op: "Add" + input: "compute_loss/add_1" + input: "compute_loss/Mean_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } +} +node { + name: "compute_loss/mul" + op: "Mul" + input: "compute_loss/mul/x" + input: "compute_loss/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/add_3/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "compute_loss/add_3" + op: "Add" + input: "compute_loss/add_3/x" + input: "compute_loss/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/strided_slice_12/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_12/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_12/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_12" + op: "StridedSlice" + input: "compute_loss/ResizeArea_1" + input: "compute_loss/strided_slice_12/stack" + input: "compute_loss/strided_slice_12/stack_1" + input: "compute_loss/strided_slice_12/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/Squeeze" + op: "Squeeze" + input: "depth_prediction/truediv" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 3 + } + } + } +} +node { + name: "compute_loss/strided_slice_13/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_13/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_13/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_13" + op: "StridedSlice" + input: "pose_and_explainability_prediction/pose_exp_net/pose/mul" + input: "compute_loss/strided_slice_13/stack" + input: "compute_loss/strided_slice_13/stack_1" + input: "compute_loss/strided_slice_13/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 5 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 5 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "compute_loss/strided_slice_14/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_14/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_14/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_14" + op: "StridedSlice" + input: "data_loading/stack_19" + input: "compute_loss/strided_slice_14/stack" + input: "compute_loss/strided_slice_14/stack_1" + input: "compute_loss/strided_slice_14/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "compute_loss/Slice/begin" + 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\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice" + op: "Slice" + input: "compute_loss/strided_slice_13" + input: "compute_loss/Slice/begin" + input: "compute_loss/Slice/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/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: "compute_loss/ExpandDims" + op: "ExpandDims" + input: "compute_loss/Slice" + input: "compute_loss/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: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_1/begin" + 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\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_1/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_1" + op: "Slice" + input: "compute_loss/strided_slice_13" + input: "compute_loss/Slice_1/begin" + input: "compute_loss/Slice_1/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_2/begin" + 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\004\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_2/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_2" + op: "Slice" + input: "compute_loss/strided_slice_13" + input: "compute_loss/Slice_2/begin" + input: "compute_loss/Slice_2/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_3/begin" + 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\005\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_3/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_3" + op: "Slice" + input: "compute_loss/strided_slice_13" + input: "compute_loss/Slice_3/begin" + input: "compute_loss/Slice_3/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_15/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: "compute_loss/strided_slice_15/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: "compute_loss/strided_slice_15/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: "compute_loss/strided_slice_15" + op: "StridedSlice" + input: "compute_loss/Shape" + input: "compute_loss/strided_slice_15/stack" + input: "compute_loss/strided_slice_15/stack_1" + input: "compute_loss/strided_slice_15/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: "compute_loss/clip_by_value/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value/Minimum" + op: "Minimum" + input: "compute_loss/Slice_3" + input: "compute_loss/clip_by_value/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value/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: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value" + op: "Maximum" + input: "compute_loss/clip_by_value/Minimum" + input: "compute_loss/clip_by_value/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_1/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_1/Minimum" + op: "Minimum" + input: "compute_loss/Slice_2" + input: "compute_loss/clip_by_value_1/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_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: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_1" + op: "Maximum" + input: "compute_loss/clip_by_value_1/Minimum" + input: "compute_loss/clip_by_value_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_2/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_2/Minimum" + op: "Minimum" + input: "compute_loss/Slice_1" + input: "compute_loss/clip_by_value_2/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_2/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_2" + op: "Maximum" + input: "compute_loss/clip_by_value_2/Minimum" + input: "compute_loss/clip_by_value_2/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_1/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: "compute_loss/ExpandDims_1" + op: "ExpandDims" + input: "compute_loss/clip_by_value" + input: "compute_loss/ExpandDims_1/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_2/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: "compute_loss/ExpandDims_2" + op: "ExpandDims" + input: "compute_loss/ExpandDims_1" + input: "compute_loss/ExpandDims_2/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_3/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: "compute_loss/ExpandDims_3" + op: "ExpandDims" + input: "compute_loss/clip_by_value_1" + input: "compute_loss/ExpandDims_3/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_4/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: "compute_loss/ExpandDims_4" + op: "ExpandDims" + input: "compute_loss/ExpandDims_3" + input: "compute_loss/ExpandDims_4/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_5/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: "compute_loss/ExpandDims_5" + op: "ExpandDims" + input: "compute_loss/clip_by_value_2" + input: "compute_loss/ExpandDims_5/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_6/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: "compute_loss/ExpandDims_6" + op: "ExpandDims" + input: "compute_loss/ExpandDims_5" + input: "compute_loss/ExpandDims_6/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/zeros/mul/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: "compute_loss/zeros/mul" + op: "Mul" + input: "compute_loss/strided_slice_15" + input: "compute_loss/zeros/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros/mul_1/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: "compute_loss/zeros/mul_1" + op: "Mul" + input: "compute_loss/zeros/mul" + input: "compute_loss/zeros/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros/mul_2/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: "compute_loss/zeros/mul_2" + op: "Mul" + input: "compute_loss/zeros/mul_1" + input: "compute_loss/zeros/mul_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros/Less/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: 1000 + } + } + } +} +node { + name: "compute_loss/zeros/Less" + op: "Less" + input: "compute_loss/zeros/mul_2" + input: "compute_loss/zeros/Less/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros/packed/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: "compute_loss/zeros/packed/2" + 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: "compute_loss/zeros/packed/3" + 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: "compute_loss/zeros/packed" + op: "Pack" + input: "compute_loss/strided_slice_15" + input: "compute_loss/zeros/packed/1" + input: "compute_loss/zeros/packed/2" + input: "compute_loss/zeros/packed/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/zeros/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: 0.0 + } + } + } +} +node { + name: "compute_loss/zeros" + op: "Fill" + input: "compute_loss/zeros/packed" + input: "compute_loss/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/ones/mul/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: "compute_loss/ones/mul" + op: "Mul" + input: "compute_loss/strided_slice_15" + input: "compute_loss/ones/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones/mul_1/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: "compute_loss/ones/mul_1" + op: "Mul" + input: "compute_loss/ones/mul" + input: "compute_loss/ones/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones/mul_2/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: "compute_loss/ones/mul_2" + op: "Mul" + input: "compute_loss/ones/mul_1" + input: "compute_loss/ones/mul_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones/Less/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: 1000 + } + } + } +} +node { + name: "compute_loss/ones/Less" + op: "Less" + input: "compute_loss/ones/mul_2" + input: "compute_loss/ones/Less/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones/packed/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: "compute_loss/ones/packed/2" + 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: "compute_loss/ones/packed/3" + 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: "compute_loss/ones/packed" + op: "Pack" + input: "compute_loss/strided_slice_15" + input: "compute_loss/ones/packed/1" + input: "compute_loss/ones/packed/2" + input: "compute_loss/ones/packed/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/ones/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: "compute_loss/ones" + op: "Fill" + input: "compute_loss/ones/packed" + input: "compute_loss/ones/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Neg" + op: "Neg" + input: "compute_loss/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/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: 3 + } + } + } +} +node { + name: "compute_loss/concat" + op: "ConcatV2" + input: "compute_loss/Cos" + input: "compute_loss/Neg" + input: "compute_loss/zeros" + input: "compute_loss/concat/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_1/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_1" + op: "ConcatV2" + input: "compute_loss/Sin" + input: "compute_loss/Cos" + input: "compute_loss/zeros" + input: "compute_loss/concat_1/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_2/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_2" + op: "ConcatV2" + input: "compute_loss/zeros" + input: "compute_loss/zeros" + input: "compute_loss/ones" + input: "compute_loss/concat_2/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_3/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_3" + op: "ConcatV2" + input: "compute_loss/concat" + input: "compute_loss/concat_1" + input: "compute_loss/concat_2" + input: "compute_loss/concat_3/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Cos_1" + op: "Cos" + input: "compute_loss/ExpandDims_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_1" + op: "Sin" + input: "compute_loss/ExpandDims_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_4/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_4" + op: "ConcatV2" + input: "compute_loss/Cos_1" + input: "compute_loss/zeros" + input: "compute_loss/Sin_1" + input: "compute_loss/concat_4/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_5/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_5" + op: "ConcatV2" + input: "compute_loss/zeros" + input: "compute_loss/ones" + input: "compute_loss/zeros" + input: "compute_loss/concat_5/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_1" + op: "Neg" + input: "compute_loss/Sin_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_6/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_6" + op: "ConcatV2" + input: "compute_loss/Neg_1" + input: "compute_loss/zeros" + input: "compute_loss/Cos_1" + input: "compute_loss/concat_6/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_7/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_7" + op: "ConcatV2" + input: "compute_loss/concat_4" + input: "compute_loss/concat_5" + input: "compute_loss/concat_6" + input: "compute_loss/concat_7/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Cos_2" + op: "Cos" + input: "compute_loss/ExpandDims_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_2" + op: "Sin" + input: "compute_loss/ExpandDims_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_8/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_8" + op: "ConcatV2" + input: "compute_loss/ones" + input: "compute_loss/zeros" + input: "compute_loss/zeros" + input: "compute_loss/concat_8/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_2" + op: "Neg" + input: "compute_loss/Sin_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_9/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_9" + op: "ConcatV2" + input: "compute_loss/zeros" + input: "compute_loss/Cos_2" + input: "compute_loss/Neg_2" + input: "compute_loss/concat_9/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_10/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_10" + op: "ConcatV2" + input: "compute_loss/zeros" + input: "compute_loss/Sin_2" + input: "compute_loss/Cos_2" + input: "compute_loss/concat_10/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_11/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_11" + op: "ConcatV2" + input: "compute_loss/concat_8" + input: "compute_loss/concat_9" + input: "compute_loss/concat_10" + input: "compute_loss/concat_11/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul" + op: "BatchMatMul" + input: "compute_loss/concat_11" + input: "compute_loss/concat_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/MatMul" + input: "compute_loss/concat_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Squeeze_1" + op: "Squeeze" + input: "compute_loss/MatMul_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 1 + } + } + } +} +node { + name: "compute_loss/Const_4" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "compute_loss/Tile/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile" + op: "Tile" + input: "compute_loss/Const_4" + input: "compute_loss/Tile/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_12/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_12" + op: "ConcatV2" + input: "compute_loss/Squeeze_1" + input: "compute_loss/ExpandDims" + input: "compute_loss/concat_12/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_13/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_13" + op: "ConcatV2" + input: "compute_loss/concat_12" + input: "compute_loss/Tile" + input: "compute_loss/concat_13/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\200\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_1/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: "compute_loss/ones_1" + op: "Fill" + input: "compute_loss/stack" + input: "compute_loss/ones_1/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/LinSpace/start" + 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: "compute_loss/LinSpace/stop" + 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: "compute_loss/LinSpace/num" + 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: 416 + } + } + } +} +node { + name: "compute_loss/LinSpace" + op: "LinSpace" + input: "compute_loss/LinSpace/start" + input: "compute_loss/LinSpace/stop" + input: "compute_loss/LinSpace/num" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_7/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: "compute_loss/ExpandDims_7" + op: "ExpandDims" + input: "compute_loss/LinSpace" + input: "compute_loss/ExpandDims_7/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/transpose/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/transpose" + op: "Transpose" + input: "compute_loss/ExpandDims_7" + input: "compute_loss/transpose/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_2" + op: "MatMul" + input: "compute_loss/ones_1" + input: "compute_loss/transpose" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/LinSpace_1/start" + 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: "compute_loss/LinSpace_1/stop" + 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: "compute_loss/LinSpace_1/num" + 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: 128 + } + } + } +} +node { + name: "compute_loss/LinSpace_1" + op: "LinSpace" + input: "compute_loss/LinSpace_1/start" + input: "compute_loss/LinSpace_1/stop" + input: "compute_loss/LinSpace_1/num" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_8/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: "compute_loss/ExpandDims_8" + op: "ExpandDims" + input: "compute_loss/LinSpace_1" + input: "compute_loss/ExpandDims_8/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\240\001\000\000" + } + } + } +} +node { + name: "compute_loss/ones_2/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: "compute_loss/ones_2" + op: "Fill" + input: "compute_loss/stack_1" + input: "compute_loss/ones_2/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 416 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/MatMul_3" + op: "MatMul" + input: "compute_loss/ExpandDims_8" + input: "compute_loss/ones_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/add_4/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "compute_loss/add_4" + op: "Add" + input: "compute_loss/MatMul_2" + input: "compute_loss/add_4/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/mul_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.5 + } + } + } +} +node { + name: "compute_loss/mul_1" + op: "Mul" + input: "compute_loss/add_4" + input: "compute_loss/mul_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/Cast/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 415 + } + } + } +} +node { + name: "compute_loss/Cast" + op: "Cast" + input: "compute_loss/Cast/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul_2" + op: "Mul" + input: "compute_loss/mul_1" + input: "compute_loss/Cast" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/add_5/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "compute_loss/add_5" + op: "Add" + input: "compute_loss/MatMul_3" + input: "compute_loss/add_5/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/mul_3/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } +} +node { + name: "compute_loss/mul_3" + op: "Mul" + input: "compute_loss/add_5" + input: "compute_loss/mul_3/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/Cast_1/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 127 + } + } + } +} +node { + name: "compute_loss/Cast_1" + op: "Cast" + input: "compute_loss/Cast_1/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul_4" + op: "Mul" + input: "compute_loss/mul_3" + input: "compute_loss/Cast_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/ones_like/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\200\000\000\000\240\001\000\000" + } + } + } +} +node { + name: "compute_loss/ones_like/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: "compute_loss/ones_like" + op: "Fill" + input: "compute_loss/ones_like/Shape" + input: "compute_loss/ones_like/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/stack_2" + op: "Pack" + input: "compute_loss/mul_2" + input: "compute_loss/mul_4" + input: "compute_loss/ones_like" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/ExpandDims_9/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: "compute_loss/ExpandDims_9" + op: "ExpandDims" + input: "compute_loss/stack_2" + input: "compute_loss/ExpandDims_9/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: 3 + } + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/Tile_1/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_1" + op: "Tile" + input: "compute_loss/ExpandDims_9" + input: "compute_loss/Tile_1/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape" + op: "Reshape" + input: "compute_loss/Squeeze" + input: "compute_loss/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: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_1/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_1" + op: "Reshape" + input: "compute_loss/Tile_1" + input: "compute_loss/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/MatrixInverse" + op: "MatrixInverse" + input: "compute_loss/strided_slice_14" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adjoint" + value { + b: false + } + } +} +node { + name: "compute_loss/MatMul_4" + op: "BatchMatMul" + input: "compute_loss/MatrixInverse" + input: "compute_loss/Reshape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 53248 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/mul_5" + op: "Mul" + input: "compute_loss/MatMul_4" + input: "compute_loss/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/ones_3/shape_as_tensor" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "compute_loss/ones_3/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: "compute_loss/ones_3" + op: "Fill" + input: "compute_loss/ones_3/shape_as_tensor" + input: "compute_loss/ones_3/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/concat_14/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_14" + op: "ConcatV2" + input: "compute_loss/mul_5" + input: "compute_loss/ones_3" + input: "compute_loss/concat_14/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_2/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\377\377\377\377\200\000\000\000\240\001\000\000" + } + } + } +} +node { + name: "compute_loss/Reshape_2" + op: "Reshape" + input: "compute_loss/concat_14" + input: "compute_loss/Reshape_2/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/Const_5" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "compute_loss/Tile_2/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_2" + op: "Tile" + input: "compute_loss/Const_5" + input: "compute_loss/Tile_2/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/zeros_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "compute_loss/concat_15/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_15" + op: "ConcatV2" + input: "compute_loss/strided_slice_14" + input: "compute_loss/zeros_1" + input: "compute_loss/concat_15/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_16/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_16" + op: "ConcatV2" + input: "compute_loss/concat_15" + input: "compute_loss/Tile_2" + input: "compute_loss/concat_16/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_5" + op: "BatchMatMul" + input: "compute_loss/concat_16" + input: "compute_loss/concat_13" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Reshape_3/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_3" + op: "Reshape" + input: "compute_loss/Reshape_2" + input: "compute_loss/Reshape_3/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_6" + op: "BatchMatMul" + input: "compute_loss/MatMul_5" + input: "compute_loss/Reshape_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Slice_4/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_4/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_4" + op: "Slice" + input: "compute_loss/MatMul_6" + input: "compute_loss/Slice_4/begin" + input: "compute_loss/Slice_4/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_5/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_5/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_5" + op: "Slice" + input: "compute_loss/MatMul_6" + input: "compute_loss/Slice_5/begin" + input: "compute_loss/Slice_5/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_6/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_6/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_6" + op: "Slice" + input: "compute_loss/MatMul_6" + input: "compute_loss/Slice_6/begin" + input: "compute_loss/Slice_6/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/add_6/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.000000013351432e-10 + } + } + } +} +node { + name: "compute_loss/add_6" + op: "Add" + input: "compute_loss/Slice_6" + input: "compute_loss/add_6/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/truediv" + op: "RealDiv" + input: "compute_loss/Slice_4" + input: "compute_loss/add_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/add_7/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.000000013351432e-10 + } + } + } +} +node { + name: "compute_loss/add_7" + op: "Add" + input: "compute_loss/Slice_6" + input: "compute_loss/add_7/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/truediv_1" + op: "RealDiv" + input: "compute_loss/Slice_5" + input: "compute_loss/add_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/concat_17/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_17" + op: "ConcatV2" + input: "compute_loss/truediv" + input: "compute_loss/truediv_1" + input: "compute_loss/concat_17/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_4/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\200\000\000\000\240\001\000\000" + } + } + } +} +node { + name: "compute_loss/Reshape_4" + op: "Reshape" + input: "compute_loss/concat_17" + input: "compute_loss/Reshape_4/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/transpose_1/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/transpose_1" + op: "Transpose" + input: "compute_loss/Reshape_4" + input: "compute_loss/transpose_1/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/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: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling/split/split_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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling/split" + op: "SplitV" + input: "compute_loss/transpose_1" + input: "compute_loss/image_sampling/Const" + input: "compute_loss/image_sampling/split/split_dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tlen" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "num_split" + value { + i: 2 + } + } +} +node { + name: "compute_loss/image_sampling/Floor" + op: "Floor" + input: "compute_loss/image_sampling/split" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/add/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "compute_loss/image_sampling/add" + op: "Add" + input: "compute_loss/image_sampling/Floor" + input: "compute_loss/image_sampling/add/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/Floor_1" + op: "Floor" + input: "compute_loss/image_sampling/split:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/add_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: 1.0 + } + } + } +} +node { + name: "compute_loss/image_sampling/add_1" + op: "Add" + input: "compute_loss/image_sampling/Floor_1" + input: "compute_loss/image_sampling/add_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling/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: 1 + } + } + } +} +node { + name: "compute_loss/image_sampling/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: 2 + } + } + } +} +node { + name: "compute_loss/image_sampling/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: "compute_loss/image_sampling/strided_slice" + op: "StridedSlice" + input: "compute_loss/image_sampling/Shape" + input: "compute_loss/image_sampling/strided_slice/stack" + input: "compute_loss/image_sampling/strided_slice/stack_1" + input: "compute_loss/image_sampling/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: "compute_loss/image_sampling/sub/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/image_sampling/sub" + op: "Sub" + input: "compute_loss/image_sampling/strided_slice" + input: "compute_loss/image_sampling/sub/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling/Cast_2" + op: "Cast" + input: "compute_loss/image_sampling/sub" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling/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: 2 + } + } + } +} +node { + name: "compute_loss/image_sampling/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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling/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: "compute_loss/image_sampling/strided_slice_1" + op: "StridedSlice" + input: "compute_loss/image_sampling/Shape_1" + input: "compute_loss/image_sampling/strided_slice_1/stack" + input: "compute_loss/image_sampling/strided_slice_1/stack_1" + input: "compute_loss/image_sampling/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: "compute_loss/image_sampling/sub_1/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: "compute_loss/image_sampling/sub_1" + op: "Sub" + input: "compute_loss/image_sampling/strided_slice_1" + input: "compute_loss/image_sampling/sub_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling/Cast_3" + op: "Cast" + input: "compute_loss/image_sampling/sub_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling/zeros" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "compute_loss/image_sampling/clip_by_value/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling/Floor" + input: "compute_loss/image_sampling/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/clip_by_value" + op: "Maximum" + input: "compute_loss/image_sampling/clip_by_value/Minimum" + input: "compute_loss/image_sampling/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/clip_by_value_1/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling/Floor_1" + input: "compute_loss/image_sampling/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/clip_by_value_1" + op: "Maximum" + input: "compute_loss/image_sampling/clip_by_value_1/Minimum" + input: "compute_loss/image_sampling/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/clip_by_value_2/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling/add" + input: "compute_loss/image_sampling/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/clip_by_value_2" + op: "Maximum" + input: "compute_loss/image_sampling/clip_by_value_2/Minimum" + input: "compute_loss/image_sampling/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/clip_by_value_3/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling/add_1" + input: "compute_loss/image_sampling/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/clip_by_value_3" + op: "Maximum" + input: "compute_loss/image_sampling/clip_by_value_3/Minimum" + input: "compute_loss/image_sampling/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/sub_2" + op: "Sub" + input: "compute_loss/image_sampling/clip_by_value_2" + input: "compute_loss/image_sampling/split" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/sub_3" + op: "Sub" + input: "compute_loss/image_sampling/split" + input: "compute_loss/image_sampling/clip_by_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/sub_4" + op: "Sub" + input: "compute_loss/image_sampling/clip_by_value_3" + input: "compute_loss/image_sampling/split:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/sub_5" + op: "Sub" + input: "compute_loss/image_sampling/split:1" + input: "compute_loss/image_sampling/clip_by_value_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/Cast_4/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 416 + } + } + } +} +node { + name: "compute_loss/image_sampling/Cast_4" + op: "Cast" + input: "compute_loss/image_sampling/Cast_4/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling/Cast_5/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 53248 + } + } + } +} +node { + name: "compute_loss/image_sampling/Cast_5" + op: "Cast" + input: "compute_loss/image_sampling/Cast_5/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling/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: "compute_loss/image_sampling/range/limit" + 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: 4 + } + } + } +} +node { + name: "compute_loss/image_sampling/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: "compute_loss/image_sampling/range" + op: "Range" + input: "compute_loss/image_sampling/range/start" + input: "compute_loss/image_sampling/range/limit" + input: "compute_loss/image_sampling/range/delta" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/Cast_6" + op: "Cast" + input: "compute_loss/image_sampling/range" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/mul" + op: "Mul" + input: "compute_loss/image_sampling/Cast_6" + input: "compute_loss/image_sampling/Cast_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/stack" + 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: 53248 + } + } + } +} +node { + name: "compute_loss/image_sampling/stack_1/values_0" + 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: 53248 + } + } + } +} +node { + name: "compute_loss/image_sampling/stack_1" + op: "Pack" + input: "compute_loss/image_sampling/stack_1/values_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: "compute_loss/image_sampling/ones/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: "compute_loss/image_sampling/ones" + op: "Fill" + input: "compute_loss/image_sampling/stack_1" + input: "compute_loss/image_sampling/ones/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 53248 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/image_sampling/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: "compute_loss/image_sampling/ExpandDims" + op: "ExpandDims" + input: "compute_loss/image_sampling/ones" + input: "compute_loss/image_sampling/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: 53248 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/transpose/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling/transpose" + op: "Transpose" + input: "compute_loss/image_sampling/ExpandDims" + input: "compute_loss/image_sampling/transpose/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling/Reshape" + op: "Reshape" + input: "compute_loss/image_sampling/mul" + input: "compute_loss/image_sampling/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: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/MatMul" + op: "MatMul" + input: "compute_loss/image_sampling/Reshape" + input: "compute_loss/image_sampling/transpose" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/image_sampling/Reshape_1/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -1 + } + } + } +} +node { + name: "compute_loss/image_sampling/Reshape_1" + op: "Reshape" + input: "compute_loss/image_sampling/MatMul" + input: "compute_loss/image_sampling/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 212992 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/Reshape_2/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling/Reshape_2" + op: "Reshape" + input: "compute_loss/image_sampling/Reshape_1" + input: "compute_loss/image_sampling/Reshape_2/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/mul_1" + op: "Mul" + input: "compute_loss/image_sampling/clip_by_value_1" + input: "compute_loss/image_sampling/Cast_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/add_2" + op: "Add" + input: "compute_loss/image_sampling/Reshape_2" + input: "compute_loss/image_sampling/mul_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/mul_2" + op: "Mul" + input: "compute_loss/image_sampling/clip_by_value_3" + input: "compute_loss/image_sampling/Cast_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/add_3" + op: "Add" + input: "compute_loss/image_sampling/Reshape_2" + input: "compute_loss/image_sampling/mul_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/add_4" + op: "Add" + input: "compute_loss/image_sampling/clip_by_value" + input: "compute_loss/image_sampling/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/Reshape_3/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: "compute_loss/image_sampling/Reshape_3" + op: "Reshape" + input: "compute_loss/image_sampling/add_4" + input: "compute_loss/image_sampling/Reshape_3/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 212992 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/add_5" + op: "Add" + input: "compute_loss/image_sampling/clip_by_value" + input: "compute_loss/image_sampling/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/add_6" + op: "Add" + input: "compute_loss/image_sampling/clip_by_value_2" + input: "compute_loss/image_sampling/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/add_7" + op: "Add" + input: "compute_loss/image_sampling/clip_by_value_2" + input: "compute_loss/image_sampling/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/stack_2" + 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: "compute_loss/image_sampling/stack_3/values_0" + 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: "compute_loss/image_sampling/stack_3/values_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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling/stack_3" + op: "Pack" + input: "compute_loss/image_sampling/stack_3/values_0" + input: "compute_loss/image_sampling/stack_3/values_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: "compute_loss/image_sampling/Reshape_4" + op: "Reshape" + input: "compute_loss/strided_slice_12" + input: "compute_loss/image_sampling/stack_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 212992 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/Cast_9" + op: "Cast" + input: "compute_loss/image_sampling/Reshape_3" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 212992 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/GatherV2/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: "compute_loss/image_sampling/GatherV2" + op: "GatherV2" + input: "compute_loss/image_sampling/Reshape_4" + input: "compute_loss/image_sampling/Cast_9" + input: "compute_loss/image_sampling/GatherV2/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 212992 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/Reshape_5/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling/Reshape_5" + op: "Reshape" + input: "compute_loss/image_sampling/GatherV2" + input: "compute_loss/image_sampling/Reshape_5/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/Cast_10" + op: "Cast" + input: "compute_loss/image_sampling/add_5" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/GatherV2_1/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: "compute_loss/image_sampling/GatherV2_1" + op: "GatherV2" + input: "compute_loss/image_sampling/Reshape_4" + input: "compute_loss/image_sampling/Cast_10" + input: "compute_loss/image_sampling/GatherV2_1/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/Reshape_6/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling/Reshape_6" + op: "Reshape" + input: "compute_loss/image_sampling/GatherV2_1" + input: "compute_loss/image_sampling/Reshape_6/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/Cast_11" + op: "Cast" + input: "compute_loss/image_sampling/add_6" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/GatherV2_2/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: "compute_loss/image_sampling/GatherV2_2" + op: "GatherV2" + input: "compute_loss/image_sampling/Reshape_4" + input: "compute_loss/image_sampling/Cast_11" + input: "compute_loss/image_sampling/GatherV2_2/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/Reshape_7/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling/Reshape_7" + op: "Reshape" + input: "compute_loss/image_sampling/GatherV2_2" + input: "compute_loss/image_sampling/Reshape_7/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/Cast_12" + op: "Cast" + input: "compute_loss/image_sampling/add_7" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/GatherV2_3/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: "compute_loss/image_sampling/GatherV2_3" + op: "GatherV2" + input: "compute_loss/image_sampling/Reshape_4" + input: "compute_loss/image_sampling/Cast_12" + input: "compute_loss/image_sampling/GatherV2_3/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/Reshape_8/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling/Reshape_8" + op: "Reshape" + input: "compute_loss/image_sampling/GatherV2_3" + input: "compute_loss/image_sampling/Reshape_8/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/mul_3" + op: "Mul" + input: "compute_loss/image_sampling/sub_2" + input: "compute_loss/image_sampling/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/mul_4" + op: "Mul" + input: "compute_loss/image_sampling/sub_2" + input: "compute_loss/image_sampling/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/mul_5" + op: "Mul" + input: "compute_loss/image_sampling/sub_3" + input: "compute_loss/image_sampling/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/mul_6" + op: "Mul" + input: "compute_loss/image_sampling/sub_3" + input: "compute_loss/image_sampling/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/mul_7" + op: "Mul" + input: "compute_loss/image_sampling/mul_3" + input: "compute_loss/image_sampling/Reshape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/mul_8" + op: "Mul" + input: "compute_loss/image_sampling/mul_4" + input: "compute_loss/image_sampling/Reshape_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/mul_9" + op: "Mul" + input: "compute_loss/image_sampling/mul_5" + input: "compute_loss/image_sampling/Reshape_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/mul_10" + op: "Mul" + input: "compute_loss/image_sampling/mul_6" + input: "compute_loss/image_sampling/Reshape_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling/AddN" + op: "AddN" + input: "compute_loss/image_sampling/mul_7" + input: "compute_loss/image_sampling/mul_8" + input: "compute_loss/image_sampling/mul_9" + input: "compute_loss/image_sampling/mul_10" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/sub_6" + op: "Sub" + input: "compute_loss/image_sampling/AddN" + input: "compute_loss/ResizeArea" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Abs_4" + op: "Abs" + input: "compute_loss/sub_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Const_6" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_4" + op: "Mean" + input: "compute_loss/Abs_4" + input: "compute_loss/Const_6" + 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: "compute_loss/add_8/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "compute_loss/add_8" + op: "Add" + input: "compute_loss/add_8/x" + input: "compute_loss/Mean_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/strided_slice_16/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_16/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_16/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_16" + op: "StridedSlice" + input: "compute_loss/ResizeArea_1" + input: "compute_loss/strided_slice_16/stack" + input: "compute_loss/strided_slice_16/stack_1" + input: "compute_loss/strided_slice_16/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/Squeeze_2" + op: "Squeeze" + input: "depth_prediction/truediv" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 3 + } + } + } +} +node { + name: "compute_loss/strided_slice_17/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_17/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_17/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_17" + op: "StridedSlice" + input: "pose_and_explainability_prediction/pose_exp_net/pose/mul" + input: "compute_loss/strided_slice_17/stack" + input: "compute_loss/strided_slice_17/stack_1" + input: "compute_loss/strided_slice_17/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 5 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 5 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "compute_loss/strided_slice_18/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_18/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_18/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_18" + op: "StridedSlice" + input: "data_loading/stack_19" + input: "compute_loss/strided_slice_18/stack" + input: "compute_loss/strided_slice_18/stack_1" + input: "compute_loss/strided_slice_18/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "compute_loss/Slice_7/begin" + 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\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_7/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_7" + op: "Slice" + input: "compute_loss/strided_slice_17" + input: "compute_loss/Slice_7/begin" + input: "compute_loss/Slice_7/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_10/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: "compute_loss/ExpandDims_10" + op: "ExpandDims" + input: "compute_loss/Slice_7" + input: "compute_loss/ExpandDims_10/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_8/begin" + 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\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_8/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_8" + op: "Slice" + input: "compute_loss/strided_slice_17" + input: "compute_loss/Slice_8/begin" + input: "compute_loss/Slice_8/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_9/begin" + 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\004\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_9/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_9" + op: "Slice" + input: "compute_loss/strided_slice_17" + input: "compute_loss/Slice_9/begin" + input: "compute_loss/Slice_9/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_10/begin" + 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\005\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_10/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_10" + op: "Slice" + input: "compute_loss/strided_slice_17" + input: "compute_loss/Slice_10/begin" + input: "compute_loss/Slice_10/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_19/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: "compute_loss/strided_slice_19/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: "compute_loss/strided_slice_19/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: "compute_loss/strided_slice_19" + op: "StridedSlice" + input: "compute_loss/Shape_1" + input: "compute_loss/strided_slice_19/stack" + input: "compute_loss/strided_slice_19/stack_1" + input: "compute_loss/strided_slice_19/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: "compute_loss/clip_by_value_3/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_3/Minimum" + op: "Minimum" + input: "compute_loss/Slice_10" + input: "compute_loss/clip_by_value_3/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_3/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_3" + op: "Maximum" + input: "compute_loss/clip_by_value_3/Minimum" + input: "compute_loss/clip_by_value_3/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_4/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_4/Minimum" + op: "Minimum" + input: "compute_loss/Slice_9" + input: "compute_loss/clip_by_value_4/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_4/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_4" + op: "Maximum" + input: "compute_loss/clip_by_value_4/Minimum" + input: "compute_loss/clip_by_value_4/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_5/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_5/Minimum" + op: "Minimum" + input: "compute_loss/Slice_8" + input: "compute_loss/clip_by_value_5/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_5/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_5" + op: "Maximum" + input: "compute_loss/clip_by_value_5/Minimum" + input: "compute_loss/clip_by_value_5/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_11/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: "compute_loss/ExpandDims_11" + op: "ExpandDims" + input: "compute_loss/clip_by_value_3" + input: "compute_loss/ExpandDims_11/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_12/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: "compute_loss/ExpandDims_12" + op: "ExpandDims" + input: "compute_loss/ExpandDims_11" + input: "compute_loss/ExpandDims_12/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_13/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: "compute_loss/ExpandDims_13" + op: "ExpandDims" + input: "compute_loss/clip_by_value_4" + input: "compute_loss/ExpandDims_13/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_14/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: "compute_loss/ExpandDims_14" + op: "ExpandDims" + input: "compute_loss/ExpandDims_13" + input: "compute_loss/ExpandDims_14/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_15/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: "compute_loss/ExpandDims_15" + op: "ExpandDims" + input: "compute_loss/clip_by_value_5" + input: "compute_loss/ExpandDims_15/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_16/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: "compute_loss/ExpandDims_16" + op: "ExpandDims" + input: "compute_loss/ExpandDims_15" + input: "compute_loss/ExpandDims_16/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/zeros_2/mul/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: "compute_loss/zeros_2/mul" + op: "Mul" + input: "compute_loss/strided_slice_19" + input: "compute_loss/zeros_2/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_2/mul_1/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: "compute_loss/zeros_2/mul_1" + op: "Mul" + input: "compute_loss/zeros_2/mul" + input: "compute_loss/zeros_2/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_2/mul_2/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: "compute_loss/zeros_2/mul_2" + op: "Mul" + input: "compute_loss/zeros_2/mul_1" + input: "compute_loss/zeros_2/mul_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_2/Less/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: 1000 + } + } + } +} +node { + name: "compute_loss/zeros_2/Less" + op: "Less" + input: "compute_loss/zeros_2/mul_2" + input: "compute_loss/zeros_2/Less/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_2/packed/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: "compute_loss/zeros_2/packed/2" + 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: "compute_loss/zeros_2/packed/3" + 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: "compute_loss/zeros_2/packed" + op: "Pack" + input: "compute_loss/strided_slice_19" + input: "compute_loss/zeros_2/packed/1" + input: "compute_loss/zeros_2/packed/2" + input: "compute_loss/zeros_2/packed/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/zeros_2/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: 0.0 + } + } + } +} +node { + name: "compute_loss/zeros_2" + op: "Fill" + input: "compute_loss/zeros_2/packed" + input: "compute_loss/zeros_2/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/ones_4/mul/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: "compute_loss/ones_4/mul" + op: "Mul" + input: "compute_loss/strided_slice_19" + input: "compute_loss/ones_4/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_4/mul_1/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: "compute_loss/ones_4/mul_1" + op: "Mul" + input: "compute_loss/ones_4/mul" + input: "compute_loss/ones_4/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_4/mul_2/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: "compute_loss/ones_4/mul_2" + op: "Mul" + input: "compute_loss/ones_4/mul_1" + input: "compute_loss/ones_4/mul_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_4/Less/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: 1000 + } + } + } +} +node { + name: "compute_loss/ones_4/Less" + op: "Less" + input: "compute_loss/ones_4/mul_2" + input: "compute_loss/ones_4/Less/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_4/packed/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: "compute_loss/ones_4/packed/2" + 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: "compute_loss/ones_4/packed/3" + 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: "compute_loss/ones_4/packed" + op: "Pack" + input: "compute_loss/strided_slice_19" + input: "compute_loss/ones_4/packed/1" + input: "compute_loss/ones_4/packed/2" + input: "compute_loss/ones_4/packed/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/ones_4/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: "compute_loss/ones_4" + op: "Fill" + input: "compute_loss/ones_4/packed" + input: "compute_loss/ones_4/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/Cos_3" + op: "Cos" + input: "compute_loss/ExpandDims_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_3" + op: "Sin" + input: "compute_loss/ExpandDims_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_3" + op: "Neg" + input: "compute_loss/Sin_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_18/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_18" + op: "ConcatV2" + input: "compute_loss/Cos_3" + input: "compute_loss/Neg_3" + input: "compute_loss/zeros_2" + input: "compute_loss/concat_18/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_19/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_19" + op: "ConcatV2" + input: "compute_loss/Sin_3" + input: "compute_loss/Cos_3" + input: "compute_loss/zeros_2" + input: "compute_loss/concat_19/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_20/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_20" + op: "ConcatV2" + input: "compute_loss/zeros_2" + input: "compute_loss/zeros_2" + input: "compute_loss/ones_4" + input: "compute_loss/concat_20/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_21/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_21" + op: "ConcatV2" + input: "compute_loss/concat_18" + input: "compute_loss/concat_19" + input: "compute_loss/concat_20" + input: "compute_loss/concat_21/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Cos_4" + op: "Cos" + input: "compute_loss/ExpandDims_14" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_4" + op: "Sin" + input: "compute_loss/ExpandDims_14" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_22/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_22" + op: "ConcatV2" + input: "compute_loss/Cos_4" + input: "compute_loss/zeros_2" + input: "compute_loss/Sin_4" + input: "compute_loss/concat_22/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_23/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_23" + op: "ConcatV2" + input: "compute_loss/zeros_2" + input: "compute_loss/ones_4" + input: "compute_loss/zeros_2" + input: "compute_loss/concat_23/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_4" + op: "Neg" + input: "compute_loss/Sin_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_24/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_24" + op: "ConcatV2" + input: "compute_loss/Neg_4" + input: "compute_loss/zeros_2" + input: "compute_loss/Cos_4" + input: "compute_loss/concat_24/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_25/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_25" + op: "ConcatV2" + input: "compute_loss/concat_22" + input: "compute_loss/concat_23" + input: "compute_loss/concat_24" + input: "compute_loss/concat_25/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Cos_5" + op: "Cos" + input: "compute_loss/ExpandDims_16" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_5" + op: "Sin" + input: "compute_loss/ExpandDims_16" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_26/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_26" + op: "ConcatV2" + input: "compute_loss/ones_4" + input: "compute_loss/zeros_2" + input: "compute_loss/zeros_2" + input: "compute_loss/concat_26/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_5" + op: "Neg" + input: "compute_loss/Sin_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_27/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_27" + op: "ConcatV2" + input: "compute_loss/zeros_2" + input: "compute_loss/Cos_5" + input: "compute_loss/Neg_5" + input: "compute_loss/concat_27/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_28/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_28" + op: "ConcatV2" + input: "compute_loss/zeros_2" + input: "compute_loss/Sin_5" + input: "compute_loss/Cos_5" + input: "compute_loss/concat_28/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_29/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_29" + op: "ConcatV2" + input: "compute_loss/concat_26" + input: "compute_loss/concat_27" + input: "compute_loss/concat_28" + input: "compute_loss/concat_29/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_7" + op: "BatchMatMul" + input: "compute_loss/concat_29" + input: "compute_loss/concat_25" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/MatMul_8" + op: "BatchMatMul" + input: "compute_loss/MatMul_7" + input: "compute_loss/concat_21" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Squeeze_3" + op: "Squeeze" + input: "compute_loss/MatMul_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 1 + } + } + } +} +node { + name: "compute_loss/Const_7" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "compute_loss/Tile_3/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_3" + op: "Tile" + input: "compute_loss/Const_7" + input: "compute_loss/Tile_3/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_30/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_30" + op: "ConcatV2" + input: "compute_loss/Squeeze_3" + input: "compute_loss/ExpandDims_10" + input: "compute_loss/concat_30/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_31/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_31" + op: "ConcatV2" + input: "compute_loss/concat_30" + input: "compute_loss/Tile_3" + input: "compute_loss/concat_31/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/stack_3" + 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: "\200\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_5/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: "compute_loss/ones_5" + op: "Fill" + input: "compute_loss/stack_3" + input: "compute_loss/ones_5/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/LinSpace_2/start" + 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: "compute_loss/LinSpace_2/stop" + 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: "compute_loss/LinSpace_2/num" + 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: 416 + } + } + } +} +node { + name: "compute_loss/LinSpace_2" + op: "LinSpace" + input: "compute_loss/LinSpace_2/start" + input: "compute_loss/LinSpace_2/stop" + input: "compute_loss/LinSpace_2/num" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_17/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: "compute_loss/ExpandDims_17" + op: "ExpandDims" + input: "compute_loss/LinSpace_2" + input: "compute_loss/ExpandDims_17/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/transpose_2/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/transpose_2" + op: "Transpose" + input: "compute_loss/ExpandDims_17" + input: "compute_loss/transpose_2/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_9" + op: "MatMul" + input: "compute_loss/ones_5" + input: "compute_loss/transpose_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/LinSpace_3/start" + 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: "compute_loss/LinSpace_3/stop" + 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: "compute_loss/LinSpace_3/num" + 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: 128 + } + } + } +} +node { + name: "compute_loss/LinSpace_3" + op: "LinSpace" + input: "compute_loss/LinSpace_3/start" + input: "compute_loss/LinSpace_3/stop" + input: "compute_loss/LinSpace_3/num" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_18/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: "compute_loss/ExpandDims_18" + op: "ExpandDims" + input: "compute_loss/LinSpace_3" + input: "compute_loss/ExpandDims_18/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/stack_4" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\240\001\000\000" + } + } + } +} +node { + name: "compute_loss/ones_6/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: "compute_loss/ones_6" + op: "Fill" + input: "compute_loss/stack_4" + input: "compute_loss/ones_6/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 416 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/MatMul_10" + op: "MatMul" + input: "compute_loss/ExpandDims_18" + input: "compute_loss/ones_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/add_9/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "compute_loss/add_9" + op: "Add" + input: "compute_loss/MatMul_9" + input: "compute_loss/add_9/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/mul_6/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } +} +node { + name: "compute_loss/mul_6" + op: "Mul" + input: "compute_loss/add_9" + input: "compute_loss/mul_6/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/Cast_2/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 415 + } + } + } +} +node { + name: "compute_loss/Cast_2" + op: "Cast" + input: "compute_loss/Cast_2/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul_7" + op: "Mul" + input: "compute_loss/mul_6" + input: "compute_loss/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/add_10/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "compute_loss/add_10" + op: "Add" + input: "compute_loss/MatMul_10" + input: "compute_loss/add_10/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/mul_8/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } +} +node { + name: "compute_loss/mul_8" + op: "Mul" + input: "compute_loss/add_10" + input: "compute_loss/mul_8/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/Cast_3/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 127 + } + } + } +} +node { + name: "compute_loss/Cast_3" + op: "Cast" + input: "compute_loss/Cast_3/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul_9" + op: "Mul" + input: "compute_loss/mul_8" + input: "compute_loss/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/ones_like_1/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\200\000\000\000\240\001\000\000" + } + } + } +} +node { + name: "compute_loss/ones_like_1/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: "compute_loss/ones_like_1" + op: "Fill" + input: "compute_loss/ones_like_1/Shape" + input: "compute_loss/ones_like_1/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/stack_5" + op: "Pack" + input: "compute_loss/mul_7" + input: "compute_loss/mul_9" + input: "compute_loss/ones_like_1" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/ExpandDims_19/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: "compute_loss/ExpandDims_19" + op: "ExpandDims" + input: "compute_loss/stack_5" + input: "compute_loss/ExpandDims_19/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: 3 + } + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/Tile_4/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_4" + op: "Tile" + input: "compute_loss/ExpandDims_19" + input: "compute_loss/Tile_4/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_5/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_5" + op: "Reshape" + input: "compute_loss/Squeeze_2" + input: "compute_loss/Reshape_5/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_6/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_6" + op: "Reshape" + input: "compute_loss/Tile_4" + input: "compute_loss/Reshape_6/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/MatrixInverse_1" + op: "MatrixInverse" + input: "compute_loss/strided_slice_18" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adjoint" + value { + b: false + } + } +} +node { + name: "compute_loss/MatMul_11" + op: "BatchMatMul" + input: "compute_loss/MatrixInverse_1" + input: "compute_loss/Reshape_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 53248 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/mul_10" + op: "Mul" + input: "compute_loss/MatMul_11" + input: "compute_loss/Reshape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/ones_7/shape_as_tensor" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "compute_loss/ones_7/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: "compute_loss/ones_7" + op: "Fill" + input: "compute_loss/ones_7/shape_as_tensor" + input: "compute_loss/ones_7/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/concat_32/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_32" + op: "ConcatV2" + input: "compute_loss/mul_10" + input: "compute_loss/ones_7" + input: "compute_loss/concat_32/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_7/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\377\377\377\377\200\000\000\000\240\001\000\000" + } + } + } +} +node { + name: "compute_loss/Reshape_7" + op: "Reshape" + input: "compute_loss/concat_32" + input: "compute_loss/Reshape_7/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/Const_8" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "compute_loss/Tile_5/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_5" + op: "Tile" + input: "compute_loss/Const_8" + input: "compute_loss/Tile_5/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/zeros_3" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "compute_loss/concat_33/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_33" + op: "ConcatV2" + input: "compute_loss/strided_slice_18" + input: "compute_loss/zeros_3" + input: "compute_loss/concat_33/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_34/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_34" + op: "ConcatV2" + input: "compute_loss/concat_33" + input: "compute_loss/Tile_5" + input: "compute_loss/concat_34/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_12" + op: "BatchMatMul" + input: "compute_loss/concat_34" + input: "compute_loss/concat_31" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Reshape_8/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_8" + op: "Reshape" + input: "compute_loss/Reshape_7" + input: "compute_loss/Reshape_8/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_13" + op: "BatchMatMul" + input: "compute_loss/MatMul_12" + input: "compute_loss/Reshape_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Slice_11/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_11/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_11" + op: "Slice" + input: "compute_loss/MatMul_13" + input: "compute_loss/Slice_11/begin" + input: "compute_loss/Slice_11/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_12/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_12/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_12" + op: "Slice" + input: "compute_loss/MatMul_13" + input: "compute_loss/Slice_12/begin" + input: "compute_loss/Slice_12/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_13/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_13/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_13" + op: "Slice" + input: "compute_loss/MatMul_13" + input: "compute_loss/Slice_13/begin" + input: "compute_loss/Slice_13/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/add_11/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: 1.000000013351432e-10 + } + } + } +} +node { + name: "compute_loss/add_11" + op: "Add" + input: "compute_loss/Slice_13" + input: "compute_loss/add_11/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/truediv_2" + op: "RealDiv" + input: "compute_loss/Slice_11" + input: "compute_loss/add_11" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/add_12/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.000000013351432e-10 + } + } + } +} +node { + name: "compute_loss/add_12" + op: "Add" + input: "compute_loss/Slice_13" + input: "compute_loss/add_12/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/truediv_3" + op: "RealDiv" + input: "compute_loss/Slice_12" + input: "compute_loss/add_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/concat_35/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_35" + op: "ConcatV2" + input: "compute_loss/truediv_2" + input: "compute_loss/truediv_3" + input: "compute_loss/concat_35/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_9/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\200\000\000\000\240\001\000\000" + } + } + } +} +node { + name: "compute_loss/Reshape_9" + op: "Reshape" + input: "compute_loss/concat_35" + input: "compute_loss/Reshape_9/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "compute_loss/transpose_3/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/transpose_3" + op: "Transpose" + input: "compute_loss/Reshape_9" + input: "compute_loss/transpose_3/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_1/split/split_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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_1/split" + op: "SplitV" + input: "compute_loss/transpose_3" + input: "compute_loss/image_sampling_1/Const" + input: "compute_loss/image_sampling_1/split/split_dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tlen" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "num_split" + value { + i: 2 + } + } +} +node { + name: "compute_loss/image_sampling_1/Floor" + op: "Floor" + input: "compute_loss/image_sampling_1/split" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/add/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_1/add" + op: "Add" + input: "compute_loss/image_sampling_1/Floor" + input: "compute_loss/image_sampling_1/add/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Floor_1" + op: "Floor" + input: "compute_loss/image_sampling_1/split:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/add_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: 1.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_1/add_1" + op: "Add" + input: "compute_loss/image_sampling_1/Floor_1" + input: "compute_loss/image_sampling_1/add_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_1/strided_slice/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/image_sampling_1/strided_slice/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "compute_loss/image_sampling_1/strided_slice/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/image_sampling_1/strided_slice" + op: "StridedSlice" + input: "compute_loss/image_sampling_1/Shape" + input: "compute_loss/image_sampling_1/strided_slice/stack" + input: "compute_loss/image_sampling_1/strided_slice/stack_1" + input: "compute_loss/image_sampling_1/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: "compute_loss/image_sampling_1/sub/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/image_sampling_1/sub" + op: "Sub" + input: "compute_loss/image_sampling_1/strided_slice" + input: "compute_loss/image_sampling_1/sub/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Cast_2" + op: "Cast" + input: "compute_loss/image_sampling_1/sub" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_1/strided_slice_1/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "compute_loss/image_sampling_1/strided_slice_1/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_1/strided_slice_1/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/image_sampling_1/strided_slice_1" + op: "StridedSlice" + input: "compute_loss/image_sampling_1/Shape_1" + input: "compute_loss/image_sampling_1/strided_slice_1/stack" + input: "compute_loss/image_sampling_1/strided_slice_1/stack_1" + input: "compute_loss/image_sampling_1/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: "compute_loss/image_sampling_1/sub_1/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: "compute_loss/image_sampling_1/sub_1" + op: "Sub" + input: "compute_loss/image_sampling_1/strided_slice_1" + input: "compute_loss/image_sampling_1/sub_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Cast_3" + op: "Cast" + input: "compute_loss/image_sampling_1/sub_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/zeros" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_1/clip_by_value/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_1/Floor" + input: "compute_loss/image_sampling_1/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/clip_by_value" + op: "Maximum" + input: "compute_loss/image_sampling_1/clip_by_value/Minimum" + input: "compute_loss/image_sampling_1/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/clip_by_value_1/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_1/Floor_1" + input: "compute_loss/image_sampling_1/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/clip_by_value_1" + op: "Maximum" + input: "compute_loss/image_sampling_1/clip_by_value_1/Minimum" + input: "compute_loss/image_sampling_1/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/clip_by_value_2/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_1/add" + input: "compute_loss/image_sampling_1/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/clip_by_value_2" + op: "Maximum" + input: "compute_loss/image_sampling_1/clip_by_value_2/Minimum" + input: "compute_loss/image_sampling_1/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/clip_by_value_3/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_1/add_1" + input: "compute_loss/image_sampling_1/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/clip_by_value_3" + op: "Maximum" + input: "compute_loss/image_sampling_1/clip_by_value_3/Minimum" + input: "compute_loss/image_sampling_1/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/sub_2" + op: "Sub" + input: "compute_loss/image_sampling_1/clip_by_value_2" + input: "compute_loss/image_sampling_1/split" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/sub_3" + op: "Sub" + input: "compute_loss/image_sampling_1/split" + input: "compute_loss/image_sampling_1/clip_by_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/sub_4" + op: "Sub" + input: "compute_loss/image_sampling_1/clip_by_value_3" + input: "compute_loss/image_sampling_1/split:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/sub_5" + op: "Sub" + input: "compute_loss/image_sampling_1/split:1" + input: "compute_loss/image_sampling_1/clip_by_value_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Cast_4/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 416 + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Cast_4" + op: "Cast" + input: "compute_loss/image_sampling_1/Cast_4/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Cast_5/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 53248 + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Cast_5" + op: "Cast" + input: "compute_loss/image_sampling_1/Cast_5/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/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: "compute_loss/image_sampling_1/range/limit" + 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: 4 + } + } + } +} +node { + name: "compute_loss/image_sampling_1/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: "compute_loss/image_sampling_1/range" + op: "Range" + input: "compute_loss/image_sampling_1/range/start" + input: "compute_loss/image_sampling_1/range/limit" + input: "compute_loss/image_sampling_1/range/delta" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Cast_6" + op: "Cast" + input: "compute_loss/image_sampling_1/range" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/mul" + op: "Mul" + input: "compute_loss/image_sampling_1/Cast_6" + input: "compute_loss/image_sampling_1/Cast_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/stack" + 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: 53248 + } + } + } +} +node { + name: "compute_loss/image_sampling_1/stack_1/values_0" + 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: 53248 + } + } + } +} +node { + name: "compute_loss/image_sampling_1/stack_1" + op: "Pack" + input: "compute_loss/image_sampling_1/stack_1/values_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: "compute_loss/image_sampling_1/ones/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: "compute_loss/image_sampling_1/ones" + op: "Fill" + input: "compute_loss/image_sampling_1/stack_1" + input: "compute_loss/image_sampling_1/ones/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 53248 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/image_sampling_1/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: "compute_loss/image_sampling_1/ExpandDims" + op: "ExpandDims" + input: "compute_loss/image_sampling_1/ones" + input: "compute_loss/image_sampling_1/ExpandDims/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 53248 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/transpose/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_1/transpose" + op: "Transpose" + input: "compute_loss/image_sampling_1/ExpandDims" + input: "compute_loss/image_sampling_1/transpose/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Reshape" + op: "Reshape" + input: "compute_loss/image_sampling_1/mul" + input: "compute_loss/image_sampling_1/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/MatMul" + op: "MatMul" + input: "compute_loss/image_sampling_1/Reshape" + input: "compute_loss/image_sampling_1/transpose" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/image_sampling_1/Reshape_1/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -1 + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Reshape_1" + op: "Reshape" + input: "compute_loss/image_sampling_1/MatMul" + input: "compute_loss/image_sampling_1/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 212992 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Reshape_2/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Reshape_2" + op: "Reshape" + input: "compute_loss/image_sampling_1/Reshape_1" + input: "compute_loss/image_sampling_1/Reshape_2/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/mul_1" + op: "Mul" + input: "compute_loss/image_sampling_1/clip_by_value_1" + input: "compute_loss/image_sampling_1/Cast_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/add_2" + op: "Add" + input: "compute_loss/image_sampling_1/Reshape_2" + input: "compute_loss/image_sampling_1/mul_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/mul_2" + op: "Mul" + input: "compute_loss/image_sampling_1/clip_by_value_3" + input: "compute_loss/image_sampling_1/Cast_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/add_3" + op: "Add" + input: "compute_loss/image_sampling_1/Reshape_2" + input: "compute_loss/image_sampling_1/mul_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/add_4" + op: "Add" + input: "compute_loss/image_sampling_1/clip_by_value" + input: "compute_loss/image_sampling_1/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Reshape_3/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: "compute_loss/image_sampling_1/Reshape_3" + op: "Reshape" + input: "compute_loss/image_sampling_1/add_4" + input: "compute_loss/image_sampling_1/Reshape_3/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 212992 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/add_5" + op: "Add" + input: "compute_loss/image_sampling_1/clip_by_value" + input: "compute_loss/image_sampling_1/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/add_6" + op: "Add" + input: "compute_loss/image_sampling_1/clip_by_value_2" + input: "compute_loss/image_sampling_1/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/add_7" + op: "Add" + input: "compute_loss/image_sampling_1/clip_by_value_2" + input: "compute_loss/image_sampling_1/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/stack_2" + 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: "compute_loss/image_sampling_1/stack_3/values_0" + 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: "compute_loss/image_sampling_1/stack_3/values_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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_1/stack_3" + op: "Pack" + input: "compute_loss/image_sampling_1/stack_3/values_0" + input: "compute_loss/image_sampling_1/stack_3/values_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: "compute_loss/image_sampling_1/Reshape_4" + op: "Reshape" + input: "compute_loss/strided_slice_16" + input: "compute_loss/image_sampling_1/stack_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 212992 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Cast_9" + op: "Cast" + input: "compute_loss/image_sampling_1/Reshape_3" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 212992 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/GatherV2/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: "compute_loss/image_sampling_1/GatherV2" + op: "GatherV2" + input: "compute_loss/image_sampling_1/Reshape_4" + input: "compute_loss/image_sampling_1/Cast_9" + input: "compute_loss/image_sampling_1/GatherV2/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 212992 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Reshape_5/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Reshape_5" + op: "Reshape" + input: "compute_loss/image_sampling_1/GatherV2" + input: "compute_loss/image_sampling_1/Reshape_5/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Cast_10" + op: "Cast" + input: "compute_loss/image_sampling_1/add_5" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/GatherV2_1/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: "compute_loss/image_sampling_1/GatherV2_1" + op: "GatherV2" + input: "compute_loss/image_sampling_1/Reshape_4" + input: "compute_loss/image_sampling_1/Cast_10" + input: "compute_loss/image_sampling_1/GatherV2_1/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Reshape_6/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Reshape_6" + op: "Reshape" + input: "compute_loss/image_sampling_1/GatherV2_1" + input: "compute_loss/image_sampling_1/Reshape_6/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Cast_11" + op: "Cast" + input: "compute_loss/image_sampling_1/add_6" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/GatherV2_2/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: "compute_loss/image_sampling_1/GatherV2_2" + op: "GatherV2" + input: "compute_loss/image_sampling_1/Reshape_4" + input: "compute_loss/image_sampling_1/Cast_11" + input: "compute_loss/image_sampling_1/GatherV2_2/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Reshape_7/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Reshape_7" + op: "Reshape" + input: "compute_loss/image_sampling_1/GatherV2_2" + input: "compute_loss/image_sampling_1/Reshape_7/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Cast_12" + op: "Cast" + input: "compute_loss/image_sampling_1/add_7" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/GatherV2_3/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: "compute_loss/image_sampling_1/GatherV2_3" + op: "GatherV2" + input: "compute_loss/image_sampling_1/Reshape_4" + input: "compute_loss/image_sampling_1/Cast_12" + input: "compute_loss/image_sampling_1/GatherV2_3/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Reshape_8/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_1/Reshape_8" + op: "Reshape" + input: "compute_loss/image_sampling_1/GatherV2_3" + input: "compute_loss/image_sampling_1/Reshape_8/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/mul_3" + op: "Mul" + input: "compute_loss/image_sampling_1/sub_2" + input: "compute_loss/image_sampling_1/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/mul_4" + op: "Mul" + input: "compute_loss/image_sampling_1/sub_2" + input: "compute_loss/image_sampling_1/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/mul_5" + op: "Mul" + input: "compute_loss/image_sampling_1/sub_3" + input: "compute_loss/image_sampling_1/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/mul_6" + op: "Mul" + input: "compute_loss/image_sampling_1/sub_3" + input: "compute_loss/image_sampling_1/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/mul_7" + op: "Mul" + input: "compute_loss/image_sampling_1/mul_3" + input: "compute_loss/image_sampling_1/Reshape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/mul_8" + op: "Mul" + input: "compute_loss/image_sampling_1/mul_4" + input: "compute_loss/image_sampling_1/Reshape_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/mul_9" + op: "Mul" + input: "compute_loss/image_sampling_1/mul_5" + input: "compute_loss/image_sampling_1/Reshape_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/mul_10" + op: "Mul" + input: "compute_loss/image_sampling_1/mul_6" + input: "compute_loss/image_sampling_1/Reshape_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_1/AddN" + op: "AddN" + input: "compute_loss/image_sampling_1/mul_7" + input: "compute_loss/image_sampling_1/mul_8" + input: "compute_loss/image_sampling_1/mul_9" + input: "compute_loss/image_sampling_1/mul_10" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/sub_7" + op: "Sub" + input: "compute_loss/image_sampling_1/AddN" + input: "compute_loss/ResizeArea" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Abs_5" + op: "Abs" + input: "compute_loss/sub_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Const_9" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_5" + op: "Mean" + input: "compute_loss/Abs_5" + input: "compute_loss/Const_9" + 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: "compute_loss/add_13" + op: "Add" + input: "compute_loss/add_8" + input: "compute_loss/Mean_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/concat_36/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_36" + op: "ConcatV2" + input: "compute_loss/image_sampling/AddN" + input: "compute_loss/image_sampling_1/AddN" + input: "compute_loss/concat_36/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "compute_loss/concat_37/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_37" + op: "ConcatV2" + input: "compute_loss/Abs_4" + input: "compute_loss/Abs_5" + input: "compute_loss/concat_37/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "compute_loss/ResizeArea_2/size" + 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\320\000\000\000" + } + } + } +} +node { + name: "compute_loss/ResizeArea_2" + op: "ResizeArea" + input: "data_loading/sub_4" + input: "compute_loss/ResizeArea_2/size" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "align_corners" + value { + b: false + } + } +} +node { + name: "compute_loss/ResizeArea_3/size" + 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\320\000\000\000" + } + } + } +} +node { + name: "compute_loss/ResizeArea_3" + op: "ResizeArea" + input: "data_loading/sub_5" + input: "compute_loss/ResizeArea_3/size" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "align_corners" + value { + b: false + } + } +} +node { + name: "compute_loss/strided_slice_20/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_20/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_20/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_20" + op: "StridedSlice" + input: "depth_prediction/depth_net/add_2" + input: "compute_loss/strided_slice_20/stack" + input: "compute_loss/strided_slice_20/stack_1" + input: "compute_loss/strided_slice_20/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_21/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_21/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\377\377\377\377\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_21/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_21" + op: "StridedSlice" + input: "depth_prediction/depth_net/add_2" + input: "compute_loss/strided_slice_21/stack" + input: "compute_loss/strided_slice_21/stack_1" + input: "compute_loss/strided_slice_21/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_8" + op: "Sub" + input: "compute_loss/strided_slice_20" + input: "compute_loss/strided_slice_21" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_22/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_22/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_22/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_22" + op: "StridedSlice" + input: "depth_prediction/depth_net/add_2" + input: "compute_loss/strided_slice_22/stack" + input: "compute_loss/strided_slice_22/stack_1" + input: "compute_loss/strided_slice_22/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_23/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_23/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\377\377\377\377\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_23/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_23" + op: "StridedSlice" + input: "depth_prediction/depth_net/add_2" + input: "compute_loss/strided_slice_23/stack" + input: "compute_loss/strided_slice_23/stack_1" + input: "compute_loss/strided_slice_23/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_9" + op: "Sub" + input: "compute_loss/strided_slice_22" + input: "compute_loss/strided_slice_23" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_24/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_24/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_24/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_24" + op: "StridedSlice" + input: "compute_loss/sub_9" + input: "compute_loss/strided_slice_24/stack" + input: "compute_loss/strided_slice_24/stack_1" + input: "compute_loss/strided_slice_24/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_25/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_25/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\377\377\377\377\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_25/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_25" + op: "StridedSlice" + input: "compute_loss/sub_9" + input: "compute_loss/strided_slice_25/stack" + input: "compute_loss/strided_slice_25/stack_1" + input: "compute_loss/strided_slice_25/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_10" + op: "Sub" + input: "compute_loss/strided_slice_24" + input: "compute_loss/strided_slice_25" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_26/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_26/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_26/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_26" + op: "StridedSlice" + input: "compute_loss/sub_9" + input: "compute_loss/strided_slice_26/stack" + input: "compute_loss/strided_slice_26/stack_1" + input: "compute_loss/strided_slice_26/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 206 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_27/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_27/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\377\377\377\377\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_27/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_27" + op: "StridedSlice" + input: "compute_loss/sub_9" + input: "compute_loss/strided_slice_27/stack" + input: "compute_loss/strided_slice_27/stack_1" + input: "compute_loss/strided_slice_27/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 206 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_11" + op: "Sub" + input: "compute_loss/strided_slice_26" + input: "compute_loss/strided_slice_27" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 206 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_28/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_28/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_28/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_28" + op: "StridedSlice" + input: "compute_loss/sub_8" + input: "compute_loss/strided_slice_28/stack" + input: "compute_loss/strided_slice_28/stack_1" + input: "compute_loss/strided_slice_28/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 62 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_29/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_29/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\377\377\377\377\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_29/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_29" + op: "StridedSlice" + input: "compute_loss/sub_8" + input: "compute_loss/strided_slice_29/stack" + input: "compute_loss/strided_slice_29/stack_1" + input: "compute_loss/strided_slice_29/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 62 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_12" + op: "Sub" + input: "compute_loss/strided_slice_28" + input: "compute_loss/strided_slice_29" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 62 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_30/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_30/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_30/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_30" + op: "StridedSlice" + input: "compute_loss/sub_8" + input: "compute_loss/strided_slice_30/stack" + input: "compute_loss/strided_slice_30/stack_1" + input: "compute_loss/strided_slice_30/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_31/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_31/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\377\377\377\377\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_31/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_31" + op: "StridedSlice" + input: "compute_loss/sub_8" + input: "compute_loss/strided_slice_31/stack" + input: "compute_loss/strided_slice_31/stack_1" + input: "compute_loss/strided_slice_31/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_13" + op: "Sub" + input: "compute_loss/strided_slice_30" + input: "compute_loss/strided_slice_31" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Abs_6" + op: "Abs" + input: "compute_loss/sub_11" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 206 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Const_10" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_6" + op: "Mean" + input: "compute_loss/Abs_6" + input: "compute_loss/Const_10" + 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: "compute_loss/Abs_7" + op: "Abs" + input: "compute_loss/sub_10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Const_11" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_7" + op: "Mean" + input: "compute_loss/Abs_7" + input: "compute_loss/Const_11" + 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: "compute_loss/add_14" + op: "Add" + input: "compute_loss/Mean_6" + input: "compute_loss/Mean_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/Abs_8" + op: "Abs" + input: "compute_loss/sub_13" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Const_12" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_8" + op: "Mean" + input: "compute_loss/Abs_8" + input: "compute_loss/Const_12" + 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: "compute_loss/add_15" + op: "Add" + input: "compute_loss/add_14" + input: "compute_loss/Mean_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/Abs_9" + op: "Abs" + input: "compute_loss/sub_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 62 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Const_13" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_9" + op: "Mean" + input: "compute_loss/Abs_9" + input: "compute_loss/Const_13" + 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: "compute_loss/add_16" + op: "Add" + input: "compute_loss/add_15" + input: "compute_loss/Mean_9" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul_11/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.25 + } + } + } +} +node { + name: "compute_loss/mul_11" + op: "Mul" + input: "compute_loss/mul_11/x" + input: "compute_loss/add_16" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/add_17" + op: "Add" + input: "compute_loss/add_3" + input: "compute_loss/mul_11" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/strided_slice_32/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_32/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_32/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_32" + op: "StridedSlice" + input: "compute_loss/ResizeArea_3" + input: "compute_loss/strided_slice_32/stack" + input: "compute_loss/strided_slice_32/stack_1" + input: "compute_loss/strided_slice_32/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/Squeeze_4" + op: "Squeeze" + input: "depth_prediction/truediv_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 3 + } + } + } +} +node { + name: "compute_loss/strided_slice_33/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_33/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_33/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_33" + op: "StridedSlice" + input: "pose_and_explainability_prediction/pose_exp_net/pose/mul" + input: "compute_loss/strided_slice_33/stack" + input: "compute_loss/strided_slice_33/stack_1" + input: "compute_loss/strided_slice_33/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 5 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 5 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "compute_loss/strided_slice_34/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_34/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_34/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_34" + op: "StridedSlice" + input: "data_loading/stack_19" + input: "compute_loss/strided_slice_34/stack" + input: "compute_loss/strided_slice_34/stack_1" + input: "compute_loss/strided_slice_34/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "compute_loss/Slice_14/begin" + 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\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_14/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_14" + op: "Slice" + input: "compute_loss/strided_slice_33" + input: "compute_loss/Slice_14/begin" + input: "compute_loss/Slice_14/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_20/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: "compute_loss/ExpandDims_20" + op: "ExpandDims" + input: "compute_loss/Slice_14" + input: "compute_loss/ExpandDims_20/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_15/begin" + 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\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_15/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_15" + op: "Slice" + input: "compute_loss/strided_slice_33" + input: "compute_loss/Slice_15/begin" + input: "compute_loss/Slice_15/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_16/begin" + 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\004\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_16/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_16" + op: "Slice" + input: "compute_loss/strided_slice_33" + input: "compute_loss/Slice_16/begin" + input: "compute_loss/Slice_16/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_17/begin" + 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\005\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_17/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_17" + op: "Slice" + input: "compute_loss/strided_slice_33" + input: "compute_loss/Slice_17/begin" + input: "compute_loss/Slice_17/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_35/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: "compute_loss/strided_slice_35/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: "compute_loss/strided_slice_35/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: "compute_loss/strided_slice_35" + op: "StridedSlice" + input: "compute_loss/Shape_2" + input: "compute_loss/strided_slice_35/stack" + input: "compute_loss/strided_slice_35/stack_1" + input: "compute_loss/strided_slice_35/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: "compute_loss/clip_by_value_6/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_6/Minimum" + op: "Minimum" + input: "compute_loss/Slice_17" + input: "compute_loss/clip_by_value_6/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_6/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_6" + op: "Maximum" + input: "compute_loss/clip_by_value_6/Minimum" + input: "compute_loss/clip_by_value_6/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_7/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_7/Minimum" + op: "Minimum" + input: "compute_loss/Slice_16" + input: "compute_loss/clip_by_value_7/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_7/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_7" + op: "Maximum" + input: "compute_loss/clip_by_value_7/Minimum" + input: "compute_loss/clip_by_value_7/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_8/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_8/Minimum" + op: "Minimum" + input: "compute_loss/Slice_15" + input: "compute_loss/clip_by_value_8/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_8/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_8" + op: "Maximum" + input: "compute_loss/clip_by_value_8/Minimum" + input: "compute_loss/clip_by_value_8/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_21/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: "compute_loss/ExpandDims_21" + op: "ExpandDims" + input: "compute_loss/clip_by_value_6" + input: "compute_loss/ExpandDims_21/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_22/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: "compute_loss/ExpandDims_22" + op: "ExpandDims" + input: "compute_loss/ExpandDims_21" + input: "compute_loss/ExpandDims_22/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_23/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: "compute_loss/ExpandDims_23" + op: "ExpandDims" + input: "compute_loss/clip_by_value_7" + input: "compute_loss/ExpandDims_23/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_24/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: "compute_loss/ExpandDims_24" + op: "ExpandDims" + input: "compute_loss/ExpandDims_23" + input: "compute_loss/ExpandDims_24/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_25/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: "compute_loss/ExpandDims_25" + op: "ExpandDims" + input: "compute_loss/clip_by_value_8" + input: "compute_loss/ExpandDims_25/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_26/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: "compute_loss/ExpandDims_26" + op: "ExpandDims" + input: "compute_loss/ExpandDims_25" + input: "compute_loss/ExpandDims_26/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/zeros_4/mul/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: "compute_loss/zeros_4/mul" + op: "Mul" + input: "compute_loss/strided_slice_35" + input: "compute_loss/zeros_4/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_4/mul_1/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: "compute_loss/zeros_4/mul_1" + op: "Mul" + input: "compute_loss/zeros_4/mul" + input: "compute_loss/zeros_4/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_4/mul_2/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: "compute_loss/zeros_4/mul_2" + op: "Mul" + input: "compute_loss/zeros_4/mul_1" + input: "compute_loss/zeros_4/mul_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_4/Less/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: 1000 + } + } + } +} +node { + name: "compute_loss/zeros_4/Less" + op: "Less" + input: "compute_loss/zeros_4/mul_2" + input: "compute_loss/zeros_4/Less/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_4/packed/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: "compute_loss/zeros_4/packed/2" + 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: "compute_loss/zeros_4/packed/3" + 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: "compute_loss/zeros_4/packed" + op: "Pack" + input: "compute_loss/strided_slice_35" + input: "compute_loss/zeros_4/packed/1" + input: "compute_loss/zeros_4/packed/2" + input: "compute_loss/zeros_4/packed/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/zeros_4/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: 0.0 + } + } + } +} +node { + name: "compute_loss/zeros_4" + op: "Fill" + input: "compute_loss/zeros_4/packed" + input: "compute_loss/zeros_4/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/ones_8/mul/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: "compute_loss/ones_8/mul" + op: "Mul" + input: "compute_loss/strided_slice_35" + input: "compute_loss/ones_8/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_8/mul_1/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: "compute_loss/ones_8/mul_1" + op: "Mul" + input: "compute_loss/ones_8/mul" + input: "compute_loss/ones_8/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_8/mul_2/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: "compute_loss/ones_8/mul_2" + op: "Mul" + input: "compute_loss/ones_8/mul_1" + input: "compute_loss/ones_8/mul_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_8/Less/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: 1000 + } + } + } +} +node { + name: "compute_loss/ones_8/Less" + op: "Less" + input: "compute_loss/ones_8/mul_2" + input: "compute_loss/ones_8/Less/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_8/packed/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: "compute_loss/ones_8/packed/2" + 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: "compute_loss/ones_8/packed/3" + 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: "compute_loss/ones_8/packed" + op: "Pack" + input: "compute_loss/strided_slice_35" + input: "compute_loss/ones_8/packed/1" + input: "compute_loss/ones_8/packed/2" + input: "compute_loss/ones_8/packed/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/ones_8/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: "compute_loss/ones_8" + op: "Fill" + input: "compute_loss/ones_8/packed" + input: "compute_loss/ones_8/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/Cos_6" + op: "Cos" + input: "compute_loss/ExpandDims_22" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_6" + op: "Sin" + input: "compute_loss/ExpandDims_22" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_6" + op: "Neg" + input: "compute_loss/Sin_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_38/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_38" + op: "ConcatV2" + input: "compute_loss/Cos_6" + input: "compute_loss/Neg_6" + input: "compute_loss/zeros_4" + input: "compute_loss/concat_38/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_39/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_39" + op: "ConcatV2" + input: "compute_loss/Sin_6" + input: "compute_loss/Cos_6" + input: "compute_loss/zeros_4" + input: "compute_loss/concat_39/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_40/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_40" + op: "ConcatV2" + input: "compute_loss/zeros_4" + input: "compute_loss/zeros_4" + input: "compute_loss/ones_8" + input: "compute_loss/concat_40/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_41/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_41" + op: "ConcatV2" + input: "compute_loss/concat_38" + input: "compute_loss/concat_39" + input: "compute_loss/concat_40" + input: "compute_loss/concat_41/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Cos_7" + op: "Cos" + input: "compute_loss/ExpandDims_24" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_7" + op: "Sin" + input: "compute_loss/ExpandDims_24" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_42/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_42" + op: "ConcatV2" + input: "compute_loss/Cos_7" + input: "compute_loss/zeros_4" + input: "compute_loss/Sin_7" + input: "compute_loss/concat_42/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_43/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_43" + op: "ConcatV2" + input: "compute_loss/zeros_4" + input: "compute_loss/ones_8" + input: "compute_loss/zeros_4" + input: "compute_loss/concat_43/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_7" + op: "Neg" + input: "compute_loss/Sin_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_44/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_44" + op: "ConcatV2" + input: "compute_loss/Neg_7" + input: "compute_loss/zeros_4" + input: "compute_loss/Cos_7" + input: "compute_loss/concat_44/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_45/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_45" + op: "ConcatV2" + input: "compute_loss/concat_42" + input: "compute_loss/concat_43" + input: "compute_loss/concat_44" + input: "compute_loss/concat_45/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Cos_8" + op: "Cos" + input: "compute_loss/ExpandDims_26" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_8" + op: "Sin" + input: "compute_loss/ExpandDims_26" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_46/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_46" + op: "ConcatV2" + input: "compute_loss/ones_8" + input: "compute_loss/zeros_4" + input: "compute_loss/zeros_4" + input: "compute_loss/concat_46/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_8" + op: "Neg" + input: "compute_loss/Sin_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_47/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_47" + op: "ConcatV2" + input: "compute_loss/zeros_4" + input: "compute_loss/Cos_8" + input: "compute_loss/Neg_8" + input: "compute_loss/concat_47/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_48/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_48" + op: "ConcatV2" + input: "compute_loss/zeros_4" + input: "compute_loss/Sin_8" + input: "compute_loss/Cos_8" + input: "compute_loss/concat_48/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_49/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_49" + op: "ConcatV2" + input: "compute_loss/concat_46" + input: "compute_loss/concat_47" + input: "compute_loss/concat_48" + input: "compute_loss/concat_49/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_14" + op: "BatchMatMul" + input: "compute_loss/concat_49" + input: "compute_loss/concat_45" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/MatMul_15" + op: "BatchMatMul" + input: "compute_loss/MatMul_14" + input: "compute_loss/concat_41" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Squeeze_5" + op: "Squeeze" + input: "compute_loss/MatMul_15" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 1 + } + } + } +} +node { + name: "compute_loss/Const_14" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "compute_loss/Tile_6/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_6" + op: "Tile" + input: "compute_loss/Const_14" + input: "compute_loss/Tile_6/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_50/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_50" + op: "ConcatV2" + input: "compute_loss/Squeeze_5" + input: "compute_loss/ExpandDims_20" + input: "compute_loss/concat_50/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_51/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_51" + op: "ConcatV2" + input: "compute_loss/concat_50" + input: "compute_loss/Tile_6" + input: "compute_loss/concat_51/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/stack_6" + 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\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_9/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: "compute_loss/ones_9" + op: "Fill" + input: "compute_loss/stack_6" + input: "compute_loss/ones_9/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/LinSpace_4/start" + 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: "compute_loss/LinSpace_4/stop" + 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: "compute_loss/LinSpace_4/num" + 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: 208 + } + } + } +} +node { + name: "compute_loss/LinSpace_4" + op: "LinSpace" + input: "compute_loss/LinSpace_4/start" + input: "compute_loss/LinSpace_4/stop" + input: "compute_loss/LinSpace_4/num" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_27/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: "compute_loss/ExpandDims_27" + op: "ExpandDims" + input: "compute_loss/LinSpace_4" + input: "compute_loss/ExpandDims_27/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/transpose_4/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/transpose_4" + op: "Transpose" + input: "compute_loss/ExpandDims_27" + input: "compute_loss/transpose_4/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_16" + op: "MatMul" + input: "compute_loss/ones_9" + input: "compute_loss/transpose_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/LinSpace_5/start" + 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: "compute_loss/LinSpace_5/stop" + 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: "compute_loss/LinSpace_5/num" + 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: 64 + } + } + } +} +node { + name: "compute_loss/LinSpace_5" + op: "LinSpace" + input: "compute_loss/LinSpace_5/start" + input: "compute_loss/LinSpace_5/stop" + input: "compute_loss/LinSpace_5/num" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_28/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: "compute_loss/ExpandDims_28" + op: "ExpandDims" + input: "compute_loss/LinSpace_5" + input: "compute_loss/ExpandDims_28/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/stack_7" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\320\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_10/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: "compute_loss/ones_10" + op: "Fill" + input: "compute_loss/stack_7" + input: "compute_loss/ones_10/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 208 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/MatMul_17" + op: "MatMul" + input: "compute_loss/ExpandDims_28" + input: "compute_loss/ones_10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/add_18/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: 1.0 + } + } + } +} +node { + name: "compute_loss/add_18" + op: "Add" + input: "compute_loss/MatMul_16" + input: "compute_loss/add_18/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/mul_12/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } +} +node { + name: "compute_loss/mul_12" + op: "Mul" + input: "compute_loss/add_18" + input: "compute_loss/mul_12/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/Cast_4/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 207 + } + } + } +} +node { + name: "compute_loss/Cast_4" + op: "Cast" + input: "compute_loss/Cast_4/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul_13" + op: "Mul" + input: "compute_loss/mul_12" + input: "compute_loss/Cast_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/add_19/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: 1.0 + } + } + } +} +node { + name: "compute_loss/add_19" + op: "Add" + input: "compute_loss/MatMul_17" + input: "compute_loss/add_19/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/mul_14/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } +} +node { + name: "compute_loss/mul_14" + op: "Mul" + input: "compute_loss/add_19" + input: "compute_loss/mul_14/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/Cast_5/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 63 + } + } + } +} +node { + name: "compute_loss/Cast_5" + op: "Cast" + input: "compute_loss/Cast_5/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul_15" + op: "Mul" + input: "compute_loss/mul_14" + input: "compute_loss/Cast_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/ones_like_2/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "@\000\000\000\320\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_like_2/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: "compute_loss/ones_like_2" + op: "Fill" + input: "compute_loss/ones_like_2/Shape" + input: "compute_loss/ones_like_2/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/stack_8" + op: "Pack" + input: "compute_loss/mul_13" + input: "compute_loss/mul_15" + input: "compute_loss/ones_like_2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/ExpandDims_29/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: "compute_loss/ExpandDims_29" + op: "ExpandDims" + input: "compute_loss/stack_8" + input: "compute_loss/ExpandDims_29/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: 3 + } + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/Tile_7/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_7" + op: "Tile" + input: "compute_loss/ExpandDims_29" + input: "compute_loss/Tile_7/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_10/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_10" + op: "Reshape" + input: "compute_loss/Squeeze_4" + input: "compute_loss/Reshape_10/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_11/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_11" + op: "Reshape" + input: "compute_loss/Tile_7" + input: "compute_loss/Reshape_11/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/MatrixInverse_2" + op: "MatrixInverse" + input: "compute_loss/strided_slice_34" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adjoint" + value { + b: false + } + } +} +node { + name: "compute_loss/MatMul_18" + op: "BatchMatMul" + input: "compute_loss/MatrixInverse_2" + input: "compute_loss/Reshape_11" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 13312 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/mul_16" + op: "Mul" + input: "compute_loss/MatMul_18" + input: "compute_loss/Reshape_10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/ones_11/shape_as_tensor" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "compute_loss/ones_11/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: "compute_loss/ones_11" + op: "Fill" + input: "compute_loss/ones_11/shape_as_tensor" + input: "compute_loss/ones_11/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/concat_52/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_52" + op: "ConcatV2" + input: "compute_loss/mul_16" + input: "compute_loss/ones_11" + input: "compute_loss/concat_52/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_12/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\377\377\377\377@\000\000\000\320\000\000\000" + } + } + } +} +node { + name: "compute_loss/Reshape_12" + op: "Reshape" + input: "compute_loss/concat_52" + input: "compute_loss/Reshape_12/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/Const_15" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "compute_loss/Tile_8/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_8" + op: "Tile" + input: "compute_loss/Const_15" + input: "compute_loss/Tile_8/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/zeros_5" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "compute_loss/concat_53/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_53" + op: "ConcatV2" + input: "compute_loss/strided_slice_34" + input: "compute_loss/zeros_5" + input: "compute_loss/concat_53/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_54/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_54" + op: "ConcatV2" + input: "compute_loss/concat_53" + input: "compute_loss/Tile_8" + input: "compute_loss/concat_54/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_19" + op: "BatchMatMul" + input: "compute_loss/concat_54" + input: "compute_loss/concat_51" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Reshape_13/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_13" + op: "Reshape" + input: "compute_loss/Reshape_12" + input: "compute_loss/Reshape_13/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_20" + op: "BatchMatMul" + input: "compute_loss/MatMul_19" + input: "compute_loss/Reshape_13" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Slice_18/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_18/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_18" + op: "Slice" + input: "compute_loss/MatMul_20" + input: "compute_loss/Slice_18/begin" + input: "compute_loss/Slice_18/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_19/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_19/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_19" + op: "Slice" + input: "compute_loss/MatMul_20" + input: "compute_loss/Slice_19/begin" + input: "compute_loss/Slice_19/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_20/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_20/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_20" + op: "Slice" + input: "compute_loss/MatMul_20" + input: "compute_loss/Slice_20/begin" + input: "compute_loss/Slice_20/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/add_20/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: 1.000000013351432e-10 + } + } + } +} +node { + name: "compute_loss/add_20" + op: "Add" + input: "compute_loss/Slice_20" + input: "compute_loss/add_20/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/truediv_4" + op: "RealDiv" + input: "compute_loss/Slice_18" + input: "compute_loss/add_20" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/add_21/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: 1.000000013351432e-10 + } + } + } +} +node { + name: "compute_loss/add_21" + op: "Add" + input: "compute_loss/Slice_20" + input: "compute_loss/add_21/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/truediv_5" + op: "RealDiv" + input: "compute_loss/Slice_19" + input: "compute_loss/add_21" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/concat_55/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_55" + op: "ConcatV2" + input: "compute_loss/truediv_4" + input: "compute_loss/truediv_5" + input: "compute_loss/concat_55/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_14/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\002\000\000\000@\000\000\000\320\000\000\000" + } + } + } +} +node { + name: "compute_loss/Reshape_14" + op: "Reshape" + input: "compute_loss/concat_55" + input: "compute_loss/Reshape_14/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/transpose_5/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/transpose_5" + op: "Transpose" + input: "compute_loss/Reshape_14" + input: "compute_loss/transpose_5/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/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: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_2/split/split_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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_2/split" + op: "SplitV" + input: "compute_loss/transpose_5" + input: "compute_loss/image_sampling_2/Const" + input: "compute_loss/image_sampling_2/split/split_dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tlen" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "num_split" + value { + i: 2 + } + } +} +node { + name: "compute_loss/image_sampling_2/Floor" + op: "Floor" + input: "compute_loss/image_sampling_2/split" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/add/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_2/add" + op: "Add" + input: "compute_loss/image_sampling_2/Floor" + input: "compute_loss/image_sampling_2/add/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Floor_1" + op: "Floor" + input: "compute_loss/image_sampling_2/split:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/add_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: 1.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_2/add_1" + op: "Add" + input: "compute_loss/image_sampling_2/Floor_1" + input: "compute_loss/image_sampling_2/add_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_2/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: 1 + } + } + } +} +node { + name: "compute_loss/image_sampling_2/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: 2 + } + } + } +} +node { + name: "compute_loss/image_sampling_2/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: "compute_loss/image_sampling_2/strided_slice" + op: "StridedSlice" + input: "compute_loss/image_sampling_2/Shape" + input: "compute_loss/image_sampling_2/strided_slice/stack" + input: "compute_loss/image_sampling_2/strided_slice/stack_1" + input: "compute_loss/image_sampling_2/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: "compute_loss/image_sampling_2/sub/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/image_sampling_2/sub" + op: "Sub" + input: "compute_loss/image_sampling_2/strided_slice" + input: "compute_loss/image_sampling_2/sub/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Cast_2" + op: "Cast" + input: "compute_loss/image_sampling_2/sub" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_2/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: 2 + } + } + } +} +node { + name: "compute_loss/image_sampling_2/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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_2/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: "compute_loss/image_sampling_2/strided_slice_1" + op: "StridedSlice" + input: "compute_loss/image_sampling_2/Shape_1" + input: "compute_loss/image_sampling_2/strided_slice_1/stack" + input: "compute_loss/image_sampling_2/strided_slice_1/stack_1" + input: "compute_loss/image_sampling_2/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: "compute_loss/image_sampling_2/sub_1/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: "compute_loss/image_sampling_2/sub_1" + op: "Sub" + input: "compute_loss/image_sampling_2/strided_slice_1" + input: "compute_loss/image_sampling_2/sub_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Cast_3" + op: "Cast" + input: "compute_loss/image_sampling_2/sub_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/zeros" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_2/clip_by_value/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_2/Floor" + input: "compute_loss/image_sampling_2/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/clip_by_value" + op: "Maximum" + input: "compute_loss/image_sampling_2/clip_by_value/Minimum" + input: "compute_loss/image_sampling_2/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/clip_by_value_1/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_2/Floor_1" + input: "compute_loss/image_sampling_2/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/clip_by_value_1" + op: "Maximum" + input: "compute_loss/image_sampling_2/clip_by_value_1/Minimum" + input: "compute_loss/image_sampling_2/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/clip_by_value_2/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_2/add" + input: "compute_loss/image_sampling_2/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/clip_by_value_2" + op: "Maximum" + input: "compute_loss/image_sampling_2/clip_by_value_2/Minimum" + input: "compute_loss/image_sampling_2/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/clip_by_value_3/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_2/add_1" + input: "compute_loss/image_sampling_2/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/clip_by_value_3" + op: "Maximum" + input: "compute_loss/image_sampling_2/clip_by_value_3/Minimum" + input: "compute_loss/image_sampling_2/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/sub_2" + op: "Sub" + input: "compute_loss/image_sampling_2/clip_by_value_2" + input: "compute_loss/image_sampling_2/split" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/sub_3" + op: "Sub" + input: "compute_loss/image_sampling_2/split" + input: "compute_loss/image_sampling_2/clip_by_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/sub_4" + op: "Sub" + input: "compute_loss/image_sampling_2/clip_by_value_3" + input: "compute_loss/image_sampling_2/split:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/sub_5" + op: "Sub" + input: "compute_loss/image_sampling_2/split:1" + input: "compute_loss/image_sampling_2/clip_by_value_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Cast_4/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 208 + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Cast_4" + op: "Cast" + input: "compute_loss/image_sampling_2/Cast_4/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Cast_5/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 13312 + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Cast_5" + op: "Cast" + input: "compute_loss/image_sampling_2/Cast_5/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/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: "compute_loss/image_sampling_2/range/limit" + 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: 4 + } + } + } +} +node { + name: "compute_loss/image_sampling_2/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: "compute_loss/image_sampling_2/range" + op: "Range" + input: "compute_loss/image_sampling_2/range/start" + input: "compute_loss/image_sampling_2/range/limit" + input: "compute_loss/image_sampling_2/range/delta" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Cast_6" + op: "Cast" + input: "compute_loss/image_sampling_2/range" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/mul" + op: "Mul" + input: "compute_loss/image_sampling_2/Cast_6" + input: "compute_loss/image_sampling_2/Cast_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/stack" + 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: 13312 + } + } + } +} +node { + name: "compute_loss/image_sampling_2/stack_1/values_0" + 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: 13312 + } + } + } +} +node { + name: "compute_loss/image_sampling_2/stack_1" + op: "Pack" + input: "compute_loss/image_sampling_2/stack_1/values_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: "compute_loss/image_sampling_2/ones/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: "compute_loss/image_sampling_2/ones" + op: "Fill" + input: "compute_loss/image_sampling_2/stack_1" + input: "compute_loss/image_sampling_2/ones/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 13312 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/image_sampling_2/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: "compute_loss/image_sampling_2/ExpandDims" + op: "ExpandDims" + input: "compute_loss/image_sampling_2/ones" + input: "compute_loss/image_sampling_2/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: 13312 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/transpose/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_2/transpose" + op: "Transpose" + input: "compute_loss/image_sampling_2/ExpandDims" + input: "compute_loss/image_sampling_2/transpose/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Reshape" + op: "Reshape" + input: "compute_loss/image_sampling_2/mul" + input: "compute_loss/image_sampling_2/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: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/MatMul" + op: "MatMul" + input: "compute_loss/image_sampling_2/Reshape" + input: "compute_loss/image_sampling_2/transpose" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/image_sampling_2/Reshape_1/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -1 + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Reshape_1" + op: "Reshape" + input: "compute_loss/image_sampling_2/MatMul" + input: "compute_loss/image_sampling_2/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Reshape_2/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Reshape_2" + op: "Reshape" + input: "compute_loss/image_sampling_2/Reshape_1" + input: "compute_loss/image_sampling_2/Reshape_2/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/mul_1" + op: "Mul" + input: "compute_loss/image_sampling_2/clip_by_value_1" + input: "compute_loss/image_sampling_2/Cast_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/add_2" + op: "Add" + input: "compute_loss/image_sampling_2/Reshape_2" + input: "compute_loss/image_sampling_2/mul_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/mul_2" + op: "Mul" + input: "compute_loss/image_sampling_2/clip_by_value_3" + input: "compute_loss/image_sampling_2/Cast_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/add_3" + op: "Add" + input: "compute_loss/image_sampling_2/Reshape_2" + input: "compute_loss/image_sampling_2/mul_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/add_4" + op: "Add" + input: "compute_loss/image_sampling_2/clip_by_value" + input: "compute_loss/image_sampling_2/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Reshape_3/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: "compute_loss/image_sampling_2/Reshape_3" + op: "Reshape" + input: "compute_loss/image_sampling_2/add_4" + input: "compute_loss/image_sampling_2/Reshape_3/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/add_5" + op: "Add" + input: "compute_loss/image_sampling_2/clip_by_value" + input: "compute_loss/image_sampling_2/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/add_6" + op: "Add" + input: "compute_loss/image_sampling_2/clip_by_value_2" + input: "compute_loss/image_sampling_2/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/add_7" + op: "Add" + input: "compute_loss/image_sampling_2/clip_by_value_2" + input: "compute_loss/image_sampling_2/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/stack_2" + 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: "compute_loss/image_sampling_2/stack_3/values_0" + 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: "compute_loss/image_sampling_2/stack_3/values_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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_2/stack_3" + op: "Pack" + input: "compute_loss/image_sampling_2/stack_3/values_0" + input: "compute_loss/image_sampling_2/stack_3/values_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: "compute_loss/image_sampling_2/Reshape_4" + op: "Reshape" + input: "compute_loss/strided_slice_32" + input: "compute_loss/image_sampling_2/stack_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 53248 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Cast_9" + op: "Cast" + input: "compute_loss/image_sampling_2/Reshape_3" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/GatherV2/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: "compute_loss/image_sampling_2/GatherV2" + op: "GatherV2" + input: "compute_loss/image_sampling_2/Reshape_4" + input: "compute_loss/image_sampling_2/Cast_9" + input: "compute_loss/image_sampling_2/GatherV2/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 53248 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Reshape_5/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Reshape_5" + op: "Reshape" + input: "compute_loss/image_sampling_2/GatherV2" + input: "compute_loss/image_sampling_2/Reshape_5/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Cast_10" + op: "Cast" + input: "compute_loss/image_sampling_2/add_5" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/GatherV2_1/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: "compute_loss/image_sampling_2/GatherV2_1" + op: "GatherV2" + input: "compute_loss/image_sampling_2/Reshape_4" + input: "compute_loss/image_sampling_2/Cast_10" + input: "compute_loss/image_sampling_2/GatherV2_1/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Reshape_6/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Reshape_6" + op: "Reshape" + input: "compute_loss/image_sampling_2/GatherV2_1" + input: "compute_loss/image_sampling_2/Reshape_6/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Cast_11" + op: "Cast" + input: "compute_loss/image_sampling_2/add_6" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/GatherV2_2/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: "compute_loss/image_sampling_2/GatherV2_2" + op: "GatherV2" + input: "compute_loss/image_sampling_2/Reshape_4" + input: "compute_loss/image_sampling_2/Cast_11" + input: "compute_loss/image_sampling_2/GatherV2_2/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Reshape_7/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Reshape_7" + op: "Reshape" + input: "compute_loss/image_sampling_2/GatherV2_2" + input: "compute_loss/image_sampling_2/Reshape_7/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Cast_12" + op: "Cast" + input: "compute_loss/image_sampling_2/add_7" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/GatherV2_3/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: "compute_loss/image_sampling_2/GatherV2_3" + op: "GatherV2" + input: "compute_loss/image_sampling_2/Reshape_4" + input: "compute_loss/image_sampling_2/Cast_12" + input: "compute_loss/image_sampling_2/GatherV2_3/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Reshape_8/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_2/Reshape_8" + op: "Reshape" + input: "compute_loss/image_sampling_2/GatherV2_3" + input: "compute_loss/image_sampling_2/Reshape_8/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/mul_3" + op: "Mul" + input: "compute_loss/image_sampling_2/sub_2" + input: "compute_loss/image_sampling_2/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/mul_4" + op: "Mul" + input: "compute_loss/image_sampling_2/sub_2" + input: "compute_loss/image_sampling_2/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/mul_5" + op: "Mul" + input: "compute_loss/image_sampling_2/sub_3" + input: "compute_loss/image_sampling_2/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/mul_6" + op: "Mul" + input: "compute_loss/image_sampling_2/sub_3" + input: "compute_loss/image_sampling_2/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/mul_7" + op: "Mul" + input: "compute_loss/image_sampling_2/mul_3" + input: "compute_loss/image_sampling_2/Reshape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/mul_8" + op: "Mul" + input: "compute_loss/image_sampling_2/mul_4" + input: "compute_loss/image_sampling_2/Reshape_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/mul_9" + op: "Mul" + input: "compute_loss/image_sampling_2/mul_5" + input: "compute_loss/image_sampling_2/Reshape_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/mul_10" + op: "Mul" + input: "compute_loss/image_sampling_2/mul_6" + input: "compute_loss/image_sampling_2/Reshape_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_2/AddN" + op: "AddN" + input: "compute_loss/image_sampling_2/mul_7" + input: "compute_loss/image_sampling_2/mul_8" + input: "compute_loss/image_sampling_2/mul_9" + input: "compute_loss/image_sampling_2/mul_10" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/sub_14" + op: "Sub" + input: "compute_loss/image_sampling_2/AddN" + input: "compute_loss/ResizeArea_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Abs_10" + op: "Abs" + input: "compute_loss/sub_14" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Const_16" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_10" + op: "Mean" + input: "compute_loss/Abs_10" + input: "compute_loss/Const_16" + 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: "compute_loss/add_22" + op: "Add" + input: "compute_loss/add_13" + input: "compute_loss/Mean_10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/strided_slice_36/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_36/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_36/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_36" + op: "StridedSlice" + input: "compute_loss/ResizeArea_3" + input: "compute_loss/strided_slice_36/stack" + input: "compute_loss/strided_slice_36/stack_1" + input: "compute_loss/strided_slice_36/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/Squeeze_6" + op: "Squeeze" + input: "depth_prediction/truediv_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 3 + } + } + } +} +node { + name: "compute_loss/strided_slice_37/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_37/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_37/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_37" + op: "StridedSlice" + input: "pose_and_explainability_prediction/pose_exp_net/pose/mul" + input: "compute_loss/strided_slice_37/stack" + input: "compute_loss/strided_slice_37/stack_1" + input: "compute_loss/strided_slice_37/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 5 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 5 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "compute_loss/strided_slice_38/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_38/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_38/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_38" + op: "StridedSlice" + input: "data_loading/stack_19" + input: "compute_loss/strided_slice_38/stack" + input: "compute_loss/strided_slice_38/stack_1" + input: "compute_loss/strided_slice_38/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "compute_loss/Slice_21/begin" + 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\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_21/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_21" + op: "Slice" + input: "compute_loss/strided_slice_37" + input: "compute_loss/Slice_21/begin" + input: "compute_loss/Slice_21/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_30/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: "compute_loss/ExpandDims_30" + op: "ExpandDims" + input: "compute_loss/Slice_21" + input: "compute_loss/ExpandDims_30/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_22/begin" + 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\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_22/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_22" + op: "Slice" + input: "compute_loss/strided_slice_37" + input: "compute_loss/Slice_22/begin" + input: "compute_loss/Slice_22/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_23/begin" + 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\004\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_23/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_23" + op: "Slice" + input: "compute_loss/strided_slice_37" + input: "compute_loss/Slice_23/begin" + input: "compute_loss/Slice_23/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_24/begin" + 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\005\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_24/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_24" + op: "Slice" + input: "compute_loss/strided_slice_37" + input: "compute_loss/Slice_24/begin" + input: "compute_loss/Slice_24/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Shape_3" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_39/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: "compute_loss/strided_slice_39/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: "compute_loss/strided_slice_39/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: "compute_loss/strided_slice_39" + op: "StridedSlice" + input: "compute_loss/Shape_3" + input: "compute_loss/strided_slice_39/stack" + input: "compute_loss/strided_slice_39/stack_1" + input: "compute_loss/strided_slice_39/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: "compute_loss/clip_by_value_9/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_9/Minimum" + op: "Minimum" + input: "compute_loss/Slice_24" + input: "compute_loss/clip_by_value_9/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_9/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_9" + op: "Maximum" + input: "compute_loss/clip_by_value_9/Minimum" + input: "compute_loss/clip_by_value_9/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_10/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_10/Minimum" + op: "Minimum" + input: "compute_loss/Slice_23" + input: "compute_loss/clip_by_value_10/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_10/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_10" + op: "Maximum" + input: "compute_loss/clip_by_value_10/Minimum" + input: "compute_loss/clip_by_value_10/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_11/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_11/Minimum" + op: "Minimum" + input: "compute_loss/Slice_22" + input: "compute_loss/clip_by_value_11/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_11/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: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_11" + op: "Maximum" + input: "compute_loss/clip_by_value_11/Minimum" + input: "compute_loss/clip_by_value_11/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_31/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: "compute_loss/ExpandDims_31" + op: "ExpandDims" + input: "compute_loss/clip_by_value_9" + input: "compute_loss/ExpandDims_31/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_32/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: "compute_loss/ExpandDims_32" + op: "ExpandDims" + input: "compute_loss/ExpandDims_31" + input: "compute_loss/ExpandDims_32/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_33/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: "compute_loss/ExpandDims_33" + op: "ExpandDims" + input: "compute_loss/clip_by_value_10" + input: "compute_loss/ExpandDims_33/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_34/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: "compute_loss/ExpandDims_34" + op: "ExpandDims" + input: "compute_loss/ExpandDims_33" + input: "compute_loss/ExpandDims_34/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_35/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: "compute_loss/ExpandDims_35" + op: "ExpandDims" + input: "compute_loss/clip_by_value_11" + input: "compute_loss/ExpandDims_35/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_36/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: "compute_loss/ExpandDims_36" + op: "ExpandDims" + input: "compute_loss/ExpandDims_35" + input: "compute_loss/ExpandDims_36/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/zeros_6/mul/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: "compute_loss/zeros_6/mul" + op: "Mul" + input: "compute_loss/strided_slice_39" + input: "compute_loss/zeros_6/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_6/mul_1/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: "compute_loss/zeros_6/mul_1" + op: "Mul" + input: "compute_loss/zeros_6/mul" + input: "compute_loss/zeros_6/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_6/mul_2/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: "compute_loss/zeros_6/mul_2" + op: "Mul" + input: "compute_loss/zeros_6/mul_1" + input: "compute_loss/zeros_6/mul_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_6/Less/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: 1000 + } + } + } +} +node { + name: "compute_loss/zeros_6/Less" + op: "Less" + input: "compute_loss/zeros_6/mul_2" + input: "compute_loss/zeros_6/Less/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_6/packed/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: "compute_loss/zeros_6/packed/2" + 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: "compute_loss/zeros_6/packed/3" + 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: "compute_loss/zeros_6/packed" + op: "Pack" + input: "compute_loss/strided_slice_39" + input: "compute_loss/zeros_6/packed/1" + input: "compute_loss/zeros_6/packed/2" + input: "compute_loss/zeros_6/packed/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/zeros_6/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: 0.0 + } + } + } +} +node { + name: "compute_loss/zeros_6" + op: "Fill" + input: "compute_loss/zeros_6/packed" + input: "compute_loss/zeros_6/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/ones_12/mul/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: "compute_loss/ones_12/mul" + op: "Mul" + input: "compute_loss/strided_slice_39" + input: "compute_loss/ones_12/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_12/mul_1/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: "compute_loss/ones_12/mul_1" + op: "Mul" + input: "compute_loss/ones_12/mul" + input: "compute_loss/ones_12/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_12/mul_2/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: "compute_loss/ones_12/mul_2" + op: "Mul" + input: "compute_loss/ones_12/mul_1" + input: "compute_loss/ones_12/mul_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_12/Less/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: 1000 + } + } + } +} +node { + name: "compute_loss/ones_12/Less" + op: "Less" + input: "compute_loss/ones_12/mul_2" + input: "compute_loss/ones_12/Less/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_12/packed/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: "compute_loss/ones_12/packed/2" + 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: "compute_loss/ones_12/packed/3" + 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: "compute_loss/ones_12/packed" + op: "Pack" + input: "compute_loss/strided_slice_39" + input: "compute_loss/ones_12/packed/1" + input: "compute_loss/ones_12/packed/2" + input: "compute_loss/ones_12/packed/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/ones_12/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: "compute_loss/ones_12" + op: "Fill" + input: "compute_loss/ones_12/packed" + input: "compute_loss/ones_12/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/Cos_9" + op: "Cos" + input: "compute_loss/ExpandDims_32" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_9" + op: "Sin" + input: "compute_loss/ExpandDims_32" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_9" + op: "Neg" + input: "compute_loss/Sin_9" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_56/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_56" + op: "ConcatV2" + input: "compute_loss/Cos_9" + input: "compute_loss/Neg_9" + input: "compute_loss/zeros_6" + input: "compute_loss/concat_56/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_57/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_57" + op: "ConcatV2" + input: "compute_loss/Sin_9" + input: "compute_loss/Cos_9" + input: "compute_loss/zeros_6" + input: "compute_loss/concat_57/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_58/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_58" + op: "ConcatV2" + input: "compute_loss/zeros_6" + input: "compute_loss/zeros_6" + input: "compute_loss/ones_12" + input: "compute_loss/concat_58/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_59/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_59" + op: "ConcatV2" + input: "compute_loss/concat_56" + input: "compute_loss/concat_57" + input: "compute_loss/concat_58" + input: "compute_loss/concat_59/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Cos_10" + op: "Cos" + input: "compute_loss/ExpandDims_34" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_10" + op: "Sin" + input: "compute_loss/ExpandDims_34" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_60/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_60" + op: "ConcatV2" + input: "compute_loss/Cos_10" + input: "compute_loss/zeros_6" + input: "compute_loss/Sin_10" + input: "compute_loss/concat_60/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_61/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_61" + op: "ConcatV2" + input: "compute_loss/zeros_6" + input: "compute_loss/ones_12" + input: "compute_loss/zeros_6" + input: "compute_loss/concat_61/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_10" + op: "Neg" + input: "compute_loss/Sin_10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_62/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_62" + op: "ConcatV2" + input: "compute_loss/Neg_10" + input: "compute_loss/zeros_6" + input: "compute_loss/Cos_10" + input: "compute_loss/concat_62/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_63/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_63" + op: "ConcatV2" + input: "compute_loss/concat_60" + input: "compute_loss/concat_61" + input: "compute_loss/concat_62" + input: "compute_loss/concat_63/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Cos_11" + op: "Cos" + input: "compute_loss/ExpandDims_36" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_11" + op: "Sin" + input: "compute_loss/ExpandDims_36" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_64/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_64" + op: "ConcatV2" + input: "compute_loss/ones_12" + input: "compute_loss/zeros_6" + input: "compute_loss/zeros_6" + input: "compute_loss/concat_64/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_11" + op: "Neg" + input: "compute_loss/Sin_11" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_65/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_65" + op: "ConcatV2" + input: "compute_loss/zeros_6" + input: "compute_loss/Cos_11" + input: "compute_loss/Neg_11" + input: "compute_loss/concat_65/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_66/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_66" + op: "ConcatV2" + input: "compute_loss/zeros_6" + input: "compute_loss/Sin_11" + input: "compute_loss/Cos_11" + input: "compute_loss/concat_66/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_67/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_67" + op: "ConcatV2" + input: "compute_loss/concat_64" + input: "compute_loss/concat_65" + input: "compute_loss/concat_66" + input: "compute_loss/concat_67/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_21" + op: "BatchMatMul" + input: "compute_loss/concat_67" + input: "compute_loss/concat_63" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/MatMul_22" + op: "BatchMatMul" + input: "compute_loss/MatMul_21" + input: "compute_loss/concat_59" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Squeeze_7" + op: "Squeeze" + input: "compute_loss/MatMul_22" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 1 + } + } + } +} +node { + name: "compute_loss/Const_17" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "compute_loss/Tile_9/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_9" + op: "Tile" + input: "compute_loss/Const_17" + input: "compute_loss/Tile_9/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_68/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_68" + op: "ConcatV2" + input: "compute_loss/Squeeze_7" + input: "compute_loss/ExpandDims_30" + input: "compute_loss/concat_68/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_69/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_69" + op: "ConcatV2" + input: "compute_loss/concat_68" + input: "compute_loss/Tile_9" + input: "compute_loss/concat_69/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/stack_9" + 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\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_13/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: "compute_loss/ones_13" + op: "Fill" + input: "compute_loss/stack_9" + input: "compute_loss/ones_13/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/LinSpace_6/start" + 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: "compute_loss/LinSpace_6/stop" + 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: "compute_loss/LinSpace_6/num" + 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: 208 + } + } + } +} +node { + name: "compute_loss/LinSpace_6" + op: "LinSpace" + input: "compute_loss/LinSpace_6/start" + input: "compute_loss/LinSpace_6/stop" + input: "compute_loss/LinSpace_6/num" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_37/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: "compute_loss/ExpandDims_37" + op: "ExpandDims" + input: "compute_loss/LinSpace_6" + input: "compute_loss/ExpandDims_37/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/transpose_6/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/transpose_6" + op: "Transpose" + input: "compute_loss/ExpandDims_37" + input: "compute_loss/transpose_6/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_23" + op: "MatMul" + input: "compute_loss/ones_13" + input: "compute_loss/transpose_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/LinSpace_7/start" + 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: "compute_loss/LinSpace_7/stop" + 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: "compute_loss/LinSpace_7/num" + 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: 64 + } + } + } +} +node { + name: "compute_loss/LinSpace_7" + op: "LinSpace" + input: "compute_loss/LinSpace_7/start" + input: "compute_loss/LinSpace_7/stop" + input: "compute_loss/LinSpace_7/num" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_38/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: "compute_loss/ExpandDims_38" + op: "ExpandDims" + input: "compute_loss/LinSpace_7" + input: "compute_loss/ExpandDims_38/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/stack_10" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\320\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_14/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: "compute_loss/ones_14" + op: "Fill" + input: "compute_loss/stack_10" + input: "compute_loss/ones_14/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 208 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/MatMul_24" + op: "MatMul" + input: "compute_loss/ExpandDims_38" + input: "compute_loss/ones_14" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/add_23/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: 1.0 + } + } + } +} +node { + name: "compute_loss/add_23" + op: "Add" + input: "compute_loss/MatMul_23" + input: "compute_loss/add_23/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/mul_17/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } +} +node { + name: "compute_loss/mul_17" + op: "Mul" + input: "compute_loss/add_23" + input: "compute_loss/mul_17/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/Cast_6/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 207 + } + } + } +} +node { + name: "compute_loss/Cast_6" + op: "Cast" + input: "compute_loss/Cast_6/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul_18" + op: "Mul" + input: "compute_loss/mul_17" + input: "compute_loss/Cast_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/add_24/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: 1.0 + } + } + } +} +node { + name: "compute_loss/add_24" + op: "Add" + input: "compute_loss/MatMul_24" + input: "compute_loss/add_24/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/mul_19/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } +} +node { + name: "compute_loss/mul_19" + op: "Mul" + input: "compute_loss/add_24" + input: "compute_loss/mul_19/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/Cast_7/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 63 + } + } + } +} +node { + name: "compute_loss/Cast_7" + op: "Cast" + input: "compute_loss/Cast_7/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul_20" + op: "Mul" + input: "compute_loss/mul_19" + input: "compute_loss/Cast_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/ones_like_3/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "@\000\000\000\320\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_like_3/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: "compute_loss/ones_like_3" + op: "Fill" + input: "compute_loss/ones_like_3/Shape" + input: "compute_loss/ones_like_3/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/stack_11" + op: "Pack" + input: "compute_loss/mul_18" + input: "compute_loss/mul_20" + input: "compute_loss/ones_like_3" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/ExpandDims_39/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: "compute_loss/ExpandDims_39" + op: "ExpandDims" + input: "compute_loss/stack_11" + input: "compute_loss/ExpandDims_39/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: 3 + } + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/Tile_10/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_10" + op: "Tile" + input: "compute_loss/ExpandDims_39" + input: "compute_loss/Tile_10/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_15/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_15" + op: "Reshape" + input: "compute_loss/Squeeze_6" + input: "compute_loss/Reshape_15/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_16/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_16" + op: "Reshape" + input: "compute_loss/Tile_10" + input: "compute_loss/Reshape_16/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/MatrixInverse_3" + op: "MatrixInverse" + input: "compute_loss/strided_slice_38" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adjoint" + value { + b: false + } + } +} +node { + name: "compute_loss/MatMul_25" + op: "BatchMatMul" + input: "compute_loss/MatrixInverse_3" + input: "compute_loss/Reshape_16" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 13312 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/mul_21" + op: "Mul" + input: "compute_loss/MatMul_25" + input: "compute_loss/Reshape_15" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/ones_15/shape_as_tensor" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "compute_loss/ones_15/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: "compute_loss/ones_15" + op: "Fill" + input: "compute_loss/ones_15/shape_as_tensor" + input: "compute_loss/ones_15/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/concat_70/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_70" + op: "ConcatV2" + input: "compute_loss/mul_21" + input: "compute_loss/ones_15" + input: "compute_loss/concat_70/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_17/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\377\377\377\377@\000\000\000\320\000\000\000" + } + } + } +} +node { + name: "compute_loss/Reshape_17" + op: "Reshape" + input: "compute_loss/concat_70" + input: "compute_loss/Reshape_17/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/Const_18" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "compute_loss/Tile_11/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_11" + op: "Tile" + input: "compute_loss/Const_18" + input: "compute_loss/Tile_11/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/zeros_7" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "compute_loss/concat_71/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_71" + op: "ConcatV2" + input: "compute_loss/strided_slice_38" + input: "compute_loss/zeros_7" + input: "compute_loss/concat_71/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_72/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_72" + op: "ConcatV2" + input: "compute_loss/concat_71" + input: "compute_loss/Tile_11" + input: "compute_loss/concat_72/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_26" + op: "BatchMatMul" + input: "compute_loss/concat_72" + input: "compute_loss/concat_69" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Reshape_18/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_18" + op: "Reshape" + input: "compute_loss/Reshape_17" + input: "compute_loss/Reshape_18/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_27" + op: "BatchMatMul" + input: "compute_loss/MatMul_26" + input: "compute_loss/Reshape_18" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Slice_25/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_25/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_25" + op: "Slice" + input: "compute_loss/MatMul_27" + input: "compute_loss/Slice_25/begin" + input: "compute_loss/Slice_25/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_26/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_26/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_26" + op: "Slice" + input: "compute_loss/MatMul_27" + input: "compute_loss/Slice_26/begin" + input: "compute_loss/Slice_26/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_27/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_27/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_27" + op: "Slice" + input: "compute_loss/MatMul_27" + input: "compute_loss/Slice_27/begin" + input: "compute_loss/Slice_27/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/add_25/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: 1.000000013351432e-10 + } + } + } +} +node { + name: "compute_loss/add_25" + op: "Add" + input: "compute_loss/Slice_27" + input: "compute_loss/add_25/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/truediv_6" + op: "RealDiv" + input: "compute_loss/Slice_25" + input: "compute_loss/add_25" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/add_26/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: 1.000000013351432e-10 + } + } + } +} +node { + name: "compute_loss/add_26" + op: "Add" + input: "compute_loss/Slice_27" + input: "compute_loss/add_26/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/truediv_7" + op: "RealDiv" + input: "compute_loss/Slice_26" + input: "compute_loss/add_26" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/concat_73/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_73" + op: "ConcatV2" + input: "compute_loss/truediv_6" + input: "compute_loss/truediv_7" + input: "compute_loss/concat_73/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_19/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\002\000\000\000@\000\000\000\320\000\000\000" + } + } + } +} +node { + name: "compute_loss/Reshape_19" + op: "Reshape" + input: "compute_loss/concat_73" + input: "compute_loss/Reshape_19/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "compute_loss/transpose_7/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/transpose_7" + op: "Transpose" + input: "compute_loss/Reshape_19" + input: "compute_loss/transpose_7/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/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: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_3/split/split_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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_3/split" + op: "SplitV" + input: "compute_loss/transpose_7" + input: "compute_loss/image_sampling_3/Const" + input: "compute_loss/image_sampling_3/split/split_dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tlen" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "num_split" + value { + i: 2 + } + } +} +node { + name: "compute_loss/image_sampling_3/Floor" + op: "Floor" + input: "compute_loss/image_sampling_3/split" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/add/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_3/add" + op: "Add" + input: "compute_loss/image_sampling_3/Floor" + input: "compute_loss/image_sampling_3/add/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Floor_1" + op: "Floor" + input: "compute_loss/image_sampling_3/split:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/add_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: 1.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_3/add_1" + op: "Add" + input: "compute_loss/image_sampling_3/Floor_1" + input: "compute_loss/image_sampling_3/add_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_3/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: 1 + } + } + } +} +node { + name: "compute_loss/image_sampling_3/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: 2 + } + } + } +} +node { + name: "compute_loss/image_sampling_3/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: "compute_loss/image_sampling_3/strided_slice" + op: "StridedSlice" + input: "compute_loss/image_sampling_3/Shape" + input: "compute_loss/image_sampling_3/strided_slice/stack" + input: "compute_loss/image_sampling_3/strided_slice/stack_1" + input: "compute_loss/image_sampling_3/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: "compute_loss/image_sampling_3/sub/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/image_sampling_3/sub" + op: "Sub" + input: "compute_loss/image_sampling_3/strided_slice" + input: "compute_loss/image_sampling_3/sub/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Cast_2" + op: "Cast" + input: "compute_loss/image_sampling_3/sub" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_3/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: 2 + } + } + } +} +node { + name: "compute_loss/image_sampling_3/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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_3/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: "compute_loss/image_sampling_3/strided_slice_1" + op: "StridedSlice" + input: "compute_loss/image_sampling_3/Shape_1" + input: "compute_loss/image_sampling_3/strided_slice_1/stack" + input: "compute_loss/image_sampling_3/strided_slice_1/stack_1" + input: "compute_loss/image_sampling_3/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: "compute_loss/image_sampling_3/sub_1/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: "compute_loss/image_sampling_3/sub_1" + op: "Sub" + input: "compute_loss/image_sampling_3/strided_slice_1" + input: "compute_loss/image_sampling_3/sub_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Cast_3" + op: "Cast" + input: "compute_loss/image_sampling_3/sub_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/zeros" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_3/clip_by_value/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_3/Floor" + input: "compute_loss/image_sampling_3/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/clip_by_value" + op: "Maximum" + input: "compute_loss/image_sampling_3/clip_by_value/Minimum" + input: "compute_loss/image_sampling_3/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/clip_by_value_1/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_3/Floor_1" + input: "compute_loss/image_sampling_3/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/clip_by_value_1" + op: "Maximum" + input: "compute_loss/image_sampling_3/clip_by_value_1/Minimum" + input: "compute_loss/image_sampling_3/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/clip_by_value_2/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_3/add" + input: "compute_loss/image_sampling_3/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/clip_by_value_2" + op: "Maximum" + input: "compute_loss/image_sampling_3/clip_by_value_2/Minimum" + input: "compute_loss/image_sampling_3/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/clip_by_value_3/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_3/add_1" + input: "compute_loss/image_sampling_3/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/clip_by_value_3" + op: "Maximum" + input: "compute_loss/image_sampling_3/clip_by_value_3/Minimum" + input: "compute_loss/image_sampling_3/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/sub_2" + op: "Sub" + input: "compute_loss/image_sampling_3/clip_by_value_2" + input: "compute_loss/image_sampling_3/split" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/sub_3" + op: "Sub" + input: "compute_loss/image_sampling_3/split" + input: "compute_loss/image_sampling_3/clip_by_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/sub_4" + op: "Sub" + input: "compute_loss/image_sampling_3/clip_by_value_3" + input: "compute_loss/image_sampling_3/split:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/sub_5" + op: "Sub" + input: "compute_loss/image_sampling_3/split:1" + input: "compute_loss/image_sampling_3/clip_by_value_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Cast_4/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 208 + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Cast_4" + op: "Cast" + input: "compute_loss/image_sampling_3/Cast_4/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Cast_5/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 13312 + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Cast_5" + op: "Cast" + input: "compute_loss/image_sampling_3/Cast_5/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/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: "compute_loss/image_sampling_3/range/limit" + 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: 4 + } + } + } +} +node { + name: "compute_loss/image_sampling_3/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: "compute_loss/image_sampling_3/range" + op: "Range" + input: "compute_loss/image_sampling_3/range/start" + input: "compute_loss/image_sampling_3/range/limit" + input: "compute_loss/image_sampling_3/range/delta" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Cast_6" + op: "Cast" + input: "compute_loss/image_sampling_3/range" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/mul" + op: "Mul" + input: "compute_loss/image_sampling_3/Cast_6" + input: "compute_loss/image_sampling_3/Cast_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/stack" + 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: 13312 + } + } + } +} +node { + name: "compute_loss/image_sampling_3/stack_1/values_0" + 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: 13312 + } + } + } +} +node { + name: "compute_loss/image_sampling_3/stack_1" + op: "Pack" + input: "compute_loss/image_sampling_3/stack_1/values_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: "compute_loss/image_sampling_3/ones/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: "compute_loss/image_sampling_3/ones" + op: "Fill" + input: "compute_loss/image_sampling_3/stack_1" + input: "compute_loss/image_sampling_3/ones/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 13312 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/image_sampling_3/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: "compute_loss/image_sampling_3/ExpandDims" + op: "ExpandDims" + input: "compute_loss/image_sampling_3/ones" + input: "compute_loss/image_sampling_3/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: 13312 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/transpose/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_3/transpose" + op: "Transpose" + input: "compute_loss/image_sampling_3/ExpandDims" + input: "compute_loss/image_sampling_3/transpose/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Reshape" + op: "Reshape" + input: "compute_loss/image_sampling_3/mul" + input: "compute_loss/image_sampling_3/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: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/MatMul" + op: "MatMul" + input: "compute_loss/image_sampling_3/Reshape" + input: "compute_loss/image_sampling_3/transpose" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/image_sampling_3/Reshape_1/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -1 + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Reshape_1" + op: "Reshape" + input: "compute_loss/image_sampling_3/MatMul" + input: "compute_loss/image_sampling_3/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Reshape_2/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Reshape_2" + op: "Reshape" + input: "compute_loss/image_sampling_3/Reshape_1" + input: "compute_loss/image_sampling_3/Reshape_2/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/mul_1" + op: "Mul" + input: "compute_loss/image_sampling_3/clip_by_value_1" + input: "compute_loss/image_sampling_3/Cast_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/add_2" + op: "Add" + input: "compute_loss/image_sampling_3/Reshape_2" + input: "compute_loss/image_sampling_3/mul_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/mul_2" + op: "Mul" + input: "compute_loss/image_sampling_3/clip_by_value_3" + input: "compute_loss/image_sampling_3/Cast_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/add_3" + op: "Add" + input: "compute_loss/image_sampling_3/Reshape_2" + input: "compute_loss/image_sampling_3/mul_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/add_4" + op: "Add" + input: "compute_loss/image_sampling_3/clip_by_value" + input: "compute_loss/image_sampling_3/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Reshape_3/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: "compute_loss/image_sampling_3/Reshape_3" + op: "Reshape" + input: "compute_loss/image_sampling_3/add_4" + input: "compute_loss/image_sampling_3/Reshape_3/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/add_5" + op: "Add" + input: "compute_loss/image_sampling_3/clip_by_value" + input: "compute_loss/image_sampling_3/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/add_6" + op: "Add" + input: "compute_loss/image_sampling_3/clip_by_value_2" + input: "compute_loss/image_sampling_3/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/add_7" + op: "Add" + input: "compute_loss/image_sampling_3/clip_by_value_2" + input: "compute_loss/image_sampling_3/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/stack_2" + 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: "compute_loss/image_sampling_3/stack_3/values_0" + 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: "compute_loss/image_sampling_3/stack_3/values_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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_3/stack_3" + op: "Pack" + input: "compute_loss/image_sampling_3/stack_3/values_0" + input: "compute_loss/image_sampling_3/stack_3/values_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: "compute_loss/image_sampling_3/Reshape_4" + op: "Reshape" + input: "compute_loss/strided_slice_36" + input: "compute_loss/image_sampling_3/stack_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 53248 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Cast_9" + op: "Cast" + input: "compute_loss/image_sampling_3/Reshape_3" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/GatherV2/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: "compute_loss/image_sampling_3/GatherV2" + op: "GatherV2" + input: "compute_loss/image_sampling_3/Reshape_4" + input: "compute_loss/image_sampling_3/Cast_9" + input: "compute_loss/image_sampling_3/GatherV2/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 53248 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Reshape_5/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Reshape_5" + op: "Reshape" + input: "compute_loss/image_sampling_3/GatherV2" + input: "compute_loss/image_sampling_3/Reshape_5/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Cast_10" + op: "Cast" + input: "compute_loss/image_sampling_3/add_5" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/GatherV2_1/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: "compute_loss/image_sampling_3/GatherV2_1" + op: "GatherV2" + input: "compute_loss/image_sampling_3/Reshape_4" + input: "compute_loss/image_sampling_3/Cast_10" + input: "compute_loss/image_sampling_3/GatherV2_1/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Reshape_6/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Reshape_6" + op: "Reshape" + input: "compute_loss/image_sampling_3/GatherV2_1" + input: "compute_loss/image_sampling_3/Reshape_6/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Cast_11" + op: "Cast" + input: "compute_loss/image_sampling_3/add_6" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/GatherV2_2/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: "compute_loss/image_sampling_3/GatherV2_2" + op: "GatherV2" + input: "compute_loss/image_sampling_3/Reshape_4" + input: "compute_loss/image_sampling_3/Cast_11" + input: "compute_loss/image_sampling_3/GatherV2_2/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Reshape_7/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Reshape_7" + op: "Reshape" + input: "compute_loss/image_sampling_3/GatherV2_2" + input: "compute_loss/image_sampling_3/Reshape_7/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Cast_12" + op: "Cast" + input: "compute_loss/image_sampling_3/add_7" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/GatherV2_3/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: "compute_loss/image_sampling_3/GatherV2_3" + op: "GatherV2" + input: "compute_loss/image_sampling_3/Reshape_4" + input: "compute_loss/image_sampling_3/Cast_12" + input: "compute_loss/image_sampling_3/GatherV2_3/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Reshape_8/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_3/Reshape_8" + op: "Reshape" + input: "compute_loss/image_sampling_3/GatherV2_3" + input: "compute_loss/image_sampling_3/Reshape_8/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/mul_3" + op: "Mul" + input: "compute_loss/image_sampling_3/sub_2" + input: "compute_loss/image_sampling_3/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/mul_4" + op: "Mul" + input: "compute_loss/image_sampling_3/sub_2" + input: "compute_loss/image_sampling_3/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/mul_5" + op: "Mul" + input: "compute_loss/image_sampling_3/sub_3" + input: "compute_loss/image_sampling_3/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/mul_6" + op: "Mul" + input: "compute_loss/image_sampling_3/sub_3" + input: "compute_loss/image_sampling_3/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/mul_7" + op: "Mul" + input: "compute_loss/image_sampling_3/mul_3" + input: "compute_loss/image_sampling_3/Reshape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/mul_8" + op: "Mul" + input: "compute_loss/image_sampling_3/mul_4" + input: "compute_loss/image_sampling_3/Reshape_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/mul_9" + op: "Mul" + input: "compute_loss/image_sampling_3/mul_5" + input: "compute_loss/image_sampling_3/Reshape_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/mul_10" + op: "Mul" + input: "compute_loss/image_sampling_3/mul_6" + input: "compute_loss/image_sampling_3/Reshape_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_3/AddN" + op: "AddN" + input: "compute_loss/image_sampling_3/mul_7" + input: "compute_loss/image_sampling_3/mul_8" + input: "compute_loss/image_sampling_3/mul_9" + input: "compute_loss/image_sampling_3/mul_10" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/sub_15" + op: "Sub" + input: "compute_loss/image_sampling_3/AddN" + input: "compute_loss/ResizeArea_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Abs_11" + op: "Abs" + input: "compute_loss/sub_15" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Const_19" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_11" + op: "Mean" + input: "compute_loss/Abs_11" + input: "compute_loss/Const_19" + 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: "compute_loss/add_27" + op: "Add" + input: "compute_loss/add_22" + input: "compute_loss/Mean_11" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/concat_74/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_74" + op: "ConcatV2" + input: "compute_loss/image_sampling_2/AddN" + input: "compute_loss/image_sampling_3/AddN" + input: "compute_loss/concat_74/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "compute_loss/concat_75/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_75" + op: "ConcatV2" + input: "compute_loss/Abs_10" + input: "compute_loss/Abs_11" + input: "compute_loss/concat_75/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "compute_loss/ResizeArea_4/size" + 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\000h\000\000\000" + } + } + } +} +node { + name: "compute_loss/ResizeArea_4" + op: "ResizeArea" + input: "data_loading/sub_4" + input: "compute_loss/ResizeArea_4/size" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "align_corners" + value { + b: false + } + } +} +node { + name: "compute_loss/ResizeArea_5/size" + 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\000h\000\000\000" + } + } + } +} +node { + name: "compute_loss/ResizeArea_5" + op: "ResizeArea" + input: "data_loading/sub_5" + input: "compute_loss/ResizeArea_5/size" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "align_corners" + value { + b: false + } + } +} +node { + name: "compute_loss/strided_slice_40/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_40/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_40/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_40" + op: "StridedSlice" + input: "depth_prediction/depth_net/add_1" + input: "compute_loss/strided_slice_40/stack" + input: "compute_loss/strided_slice_40/stack_1" + input: "compute_loss/strided_slice_40/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_41/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_41/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\377\377\377\377\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_41/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_41" + op: "StridedSlice" + input: "depth_prediction/depth_net/add_1" + input: "compute_loss/strided_slice_41/stack" + input: "compute_loss/strided_slice_41/stack_1" + input: "compute_loss/strided_slice_41/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_16" + op: "Sub" + input: "compute_loss/strided_slice_40" + input: "compute_loss/strided_slice_41" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_42/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_42/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_42/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_42" + op: "StridedSlice" + input: "depth_prediction/depth_net/add_1" + input: "compute_loss/strided_slice_42/stack" + input: "compute_loss/strided_slice_42/stack_1" + input: "compute_loss/strided_slice_42/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_43/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_43/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\377\377\377\377\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_43/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_43" + op: "StridedSlice" + input: "depth_prediction/depth_net/add_1" + input: "compute_loss/strided_slice_43/stack" + input: "compute_loss/strided_slice_43/stack_1" + input: "compute_loss/strided_slice_43/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_17" + op: "Sub" + input: "compute_loss/strided_slice_42" + input: "compute_loss/strided_slice_43" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_44/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_44/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_44/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_44" + op: "StridedSlice" + input: "compute_loss/sub_17" + input: "compute_loss/strided_slice_44/stack" + input: "compute_loss/strided_slice_44/stack_1" + input: "compute_loss/strided_slice_44/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_45/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_45/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\377\377\377\377\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_45/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_45" + op: "StridedSlice" + input: "compute_loss/sub_17" + input: "compute_loss/strided_slice_45/stack" + input: "compute_loss/strided_slice_45/stack_1" + input: "compute_loss/strided_slice_45/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_18" + op: "Sub" + input: "compute_loss/strided_slice_44" + input: "compute_loss/strided_slice_45" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_46/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_46/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_46/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_46" + op: "StridedSlice" + input: "compute_loss/sub_17" + input: "compute_loss/strided_slice_46/stack" + input: "compute_loss/strided_slice_46/stack_1" + input: "compute_loss/strided_slice_46/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 102 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_47/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_47/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\377\377\377\377\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_47/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_47" + op: "StridedSlice" + input: "compute_loss/sub_17" + input: "compute_loss/strided_slice_47/stack" + input: "compute_loss/strided_slice_47/stack_1" + input: "compute_loss/strided_slice_47/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 102 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_19" + op: "Sub" + input: "compute_loss/strided_slice_46" + input: "compute_loss/strided_slice_47" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 102 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_48/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_48/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_48/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_48" + op: "StridedSlice" + input: "compute_loss/sub_16" + input: "compute_loss/strided_slice_48/stack" + input: "compute_loss/strided_slice_48/stack_1" + input: "compute_loss/strided_slice_48/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 30 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_49/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_49/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\377\377\377\377\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_49/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_49" + op: "StridedSlice" + input: "compute_loss/sub_16" + input: "compute_loss/strided_slice_49/stack" + input: "compute_loss/strided_slice_49/stack_1" + input: "compute_loss/strided_slice_49/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 30 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_20" + op: "Sub" + input: "compute_loss/strided_slice_48" + input: "compute_loss/strided_slice_49" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 30 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_50/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_50/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_50/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_50" + op: "StridedSlice" + input: "compute_loss/sub_16" + input: "compute_loss/strided_slice_50/stack" + input: "compute_loss/strided_slice_50/stack_1" + input: "compute_loss/strided_slice_50/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_51/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_51/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\377\377\377\377\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_51/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_51" + op: "StridedSlice" + input: "compute_loss/sub_16" + input: "compute_loss/strided_slice_51/stack" + input: "compute_loss/strided_slice_51/stack_1" + input: "compute_loss/strided_slice_51/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_21" + op: "Sub" + input: "compute_loss/strided_slice_50" + input: "compute_loss/strided_slice_51" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Abs_12" + op: "Abs" + input: "compute_loss/sub_19" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 102 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Const_20" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_12" + op: "Mean" + input: "compute_loss/Abs_12" + input: "compute_loss/Const_20" + 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: "compute_loss/Abs_13" + op: "Abs" + input: "compute_loss/sub_18" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Const_21" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_13" + op: "Mean" + input: "compute_loss/Abs_13" + input: "compute_loss/Const_21" + 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: "compute_loss/add_28" + op: "Add" + input: "compute_loss/Mean_12" + input: "compute_loss/Mean_13" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/Abs_14" + op: "Abs" + input: "compute_loss/sub_21" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Const_22" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_14" + op: "Mean" + input: "compute_loss/Abs_14" + input: "compute_loss/Const_22" + 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: "compute_loss/add_29" + op: "Add" + input: "compute_loss/add_28" + input: "compute_loss/Mean_14" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/Abs_15" + op: "Abs" + input: "compute_loss/sub_20" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 30 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Const_23" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_15" + op: "Mean" + input: "compute_loss/Abs_15" + input: "compute_loss/Const_23" + 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: "compute_loss/add_30" + op: "Add" + input: "compute_loss/add_29" + input: "compute_loss/Mean_15" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul_22/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.125 + } + } + } +} +node { + name: "compute_loss/mul_22" + op: "Mul" + input: "compute_loss/mul_22/x" + input: "compute_loss/add_30" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/add_31" + op: "Add" + input: "compute_loss/add_17" + input: "compute_loss/mul_22" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/strided_slice_52/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_52/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_52/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_52" + op: "StridedSlice" + input: "compute_loss/ResizeArea_5" + input: "compute_loss/strided_slice_52/stack" + input: "compute_loss/strided_slice_52/stack_1" + input: "compute_loss/strided_slice_52/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/Squeeze_8" + op: "Squeeze" + input: "depth_prediction/truediv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 3 + } + } + } +} +node { + name: "compute_loss/strided_slice_53/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_53/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_53/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_53" + op: "StridedSlice" + input: "pose_and_explainability_prediction/pose_exp_net/pose/mul" + input: "compute_loss/strided_slice_53/stack" + input: "compute_loss/strided_slice_53/stack_1" + input: "compute_loss/strided_slice_53/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 5 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 5 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "compute_loss/strided_slice_54/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_54/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\003\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_54/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_54" + op: "StridedSlice" + input: "data_loading/stack_19" + input: "compute_loss/strided_slice_54/stack" + input: "compute_loss/strided_slice_54/stack_1" + input: "compute_loss/strided_slice_54/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "compute_loss/Slice_28/begin" + 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\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_28/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_28" + op: "Slice" + input: "compute_loss/strided_slice_53" + input: "compute_loss/Slice_28/begin" + input: "compute_loss/Slice_28/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_40/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: "compute_loss/ExpandDims_40" + op: "ExpandDims" + input: "compute_loss/Slice_28" + input: "compute_loss/ExpandDims_40/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_29/begin" + 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\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_29/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_29" + op: "Slice" + input: "compute_loss/strided_slice_53" + input: "compute_loss/Slice_29/begin" + input: "compute_loss/Slice_29/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_30/begin" + 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\004\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_30/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_30" + op: "Slice" + input: "compute_loss/strided_slice_53" + input: "compute_loss/Slice_30/begin" + input: "compute_loss/Slice_30/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_31/begin" + 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\005\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_31/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_31" + op: "Slice" + input: "compute_loss/strided_slice_53" + input: "compute_loss/Slice_31/begin" + input: "compute_loss/Slice_31/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Shape_4" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_55/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: "compute_loss/strided_slice_55/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: "compute_loss/strided_slice_55/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: "compute_loss/strided_slice_55" + op: "StridedSlice" + input: "compute_loss/Shape_4" + input: "compute_loss/strided_slice_55/stack" + input: "compute_loss/strided_slice_55/stack_1" + input: "compute_loss/strided_slice_55/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: "compute_loss/clip_by_value_12/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_12/Minimum" + op: "Minimum" + input: "compute_loss/Slice_31" + input: "compute_loss/clip_by_value_12/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_12/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_12" + op: "Maximum" + input: "compute_loss/clip_by_value_12/Minimum" + input: "compute_loss/clip_by_value_12/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_13/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_13/Minimum" + op: "Minimum" + input: "compute_loss/Slice_30" + input: "compute_loss/clip_by_value_13/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_13/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: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_13" + op: "Maximum" + input: "compute_loss/clip_by_value_13/Minimum" + input: "compute_loss/clip_by_value_13/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_14/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_14/Minimum" + op: "Minimum" + input: "compute_loss/Slice_29" + input: "compute_loss/clip_by_value_14/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_14/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: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_14" + op: "Maximum" + input: "compute_loss/clip_by_value_14/Minimum" + input: "compute_loss/clip_by_value_14/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_41/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: "compute_loss/ExpandDims_41" + op: "ExpandDims" + input: "compute_loss/clip_by_value_12" + input: "compute_loss/ExpandDims_41/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_42/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: "compute_loss/ExpandDims_42" + op: "ExpandDims" + input: "compute_loss/ExpandDims_41" + input: "compute_loss/ExpandDims_42/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_43/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: "compute_loss/ExpandDims_43" + op: "ExpandDims" + input: "compute_loss/clip_by_value_13" + input: "compute_loss/ExpandDims_43/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_44/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: "compute_loss/ExpandDims_44" + op: "ExpandDims" + input: "compute_loss/ExpandDims_43" + input: "compute_loss/ExpandDims_44/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_45/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: "compute_loss/ExpandDims_45" + op: "ExpandDims" + input: "compute_loss/clip_by_value_14" + input: "compute_loss/ExpandDims_45/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_46/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: "compute_loss/ExpandDims_46" + op: "ExpandDims" + input: "compute_loss/ExpandDims_45" + input: "compute_loss/ExpandDims_46/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/zeros_8/mul/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: "compute_loss/zeros_8/mul" + op: "Mul" + input: "compute_loss/strided_slice_55" + input: "compute_loss/zeros_8/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_8/mul_1/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: "compute_loss/zeros_8/mul_1" + op: "Mul" + input: "compute_loss/zeros_8/mul" + input: "compute_loss/zeros_8/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_8/mul_2/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: "compute_loss/zeros_8/mul_2" + op: "Mul" + input: "compute_loss/zeros_8/mul_1" + input: "compute_loss/zeros_8/mul_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_8/Less/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: 1000 + } + } + } +} +node { + name: "compute_loss/zeros_8/Less" + op: "Less" + input: "compute_loss/zeros_8/mul_2" + input: "compute_loss/zeros_8/Less/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_8/packed/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: "compute_loss/zeros_8/packed/2" + 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: "compute_loss/zeros_8/packed/3" + 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: "compute_loss/zeros_8/packed" + op: "Pack" + input: "compute_loss/strided_slice_55" + input: "compute_loss/zeros_8/packed/1" + input: "compute_loss/zeros_8/packed/2" + input: "compute_loss/zeros_8/packed/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/zeros_8/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: 0.0 + } + } + } +} +node { + name: "compute_loss/zeros_8" + op: "Fill" + input: "compute_loss/zeros_8/packed" + input: "compute_loss/zeros_8/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/ones_16/mul/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: "compute_loss/ones_16/mul" + op: "Mul" + input: "compute_loss/strided_slice_55" + input: "compute_loss/ones_16/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_16/mul_1/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: "compute_loss/ones_16/mul_1" + op: "Mul" + input: "compute_loss/ones_16/mul" + input: "compute_loss/ones_16/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_16/mul_2/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: "compute_loss/ones_16/mul_2" + op: "Mul" + input: "compute_loss/ones_16/mul_1" + input: "compute_loss/ones_16/mul_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_16/Less/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: 1000 + } + } + } +} +node { + name: "compute_loss/ones_16/Less" + op: "Less" + input: "compute_loss/ones_16/mul_2" + input: "compute_loss/ones_16/Less/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_16/packed/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: "compute_loss/ones_16/packed/2" + 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: "compute_loss/ones_16/packed/3" + 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: "compute_loss/ones_16/packed" + op: "Pack" + input: "compute_loss/strided_slice_55" + input: "compute_loss/ones_16/packed/1" + input: "compute_loss/ones_16/packed/2" + input: "compute_loss/ones_16/packed/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/ones_16/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: "compute_loss/ones_16" + op: "Fill" + input: "compute_loss/ones_16/packed" + input: "compute_loss/ones_16/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/Cos_12" + op: "Cos" + input: "compute_loss/ExpandDims_42" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_12" + op: "Sin" + input: "compute_loss/ExpandDims_42" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_12" + op: "Neg" + input: "compute_loss/Sin_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_76/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_76" + op: "ConcatV2" + input: "compute_loss/Cos_12" + input: "compute_loss/Neg_12" + input: "compute_loss/zeros_8" + input: "compute_loss/concat_76/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_77/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_77" + op: "ConcatV2" + input: "compute_loss/Sin_12" + input: "compute_loss/Cos_12" + input: "compute_loss/zeros_8" + input: "compute_loss/concat_77/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_78/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_78" + op: "ConcatV2" + input: "compute_loss/zeros_8" + input: "compute_loss/zeros_8" + input: "compute_loss/ones_16" + input: "compute_loss/concat_78/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_79/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_79" + op: "ConcatV2" + input: "compute_loss/concat_76" + input: "compute_loss/concat_77" + input: "compute_loss/concat_78" + input: "compute_loss/concat_79/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Cos_13" + op: "Cos" + input: "compute_loss/ExpandDims_44" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_13" + op: "Sin" + input: "compute_loss/ExpandDims_44" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_80/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_80" + op: "ConcatV2" + input: "compute_loss/Cos_13" + input: "compute_loss/zeros_8" + input: "compute_loss/Sin_13" + input: "compute_loss/concat_80/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_81/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_81" + op: "ConcatV2" + input: "compute_loss/zeros_8" + input: "compute_loss/ones_16" + input: "compute_loss/zeros_8" + input: "compute_loss/concat_81/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_13" + op: "Neg" + input: "compute_loss/Sin_13" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_82/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_82" + op: "ConcatV2" + input: "compute_loss/Neg_13" + input: "compute_loss/zeros_8" + input: "compute_loss/Cos_13" + input: "compute_loss/concat_82/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_83/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_83" + op: "ConcatV2" + input: "compute_loss/concat_80" + input: "compute_loss/concat_81" + input: "compute_loss/concat_82" + input: "compute_loss/concat_83/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Cos_14" + op: "Cos" + input: "compute_loss/ExpandDims_46" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_14" + op: "Sin" + input: "compute_loss/ExpandDims_46" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_84/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_84" + op: "ConcatV2" + input: "compute_loss/ones_16" + input: "compute_loss/zeros_8" + input: "compute_loss/zeros_8" + input: "compute_loss/concat_84/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_14" + op: "Neg" + input: "compute_loss/Sin_14" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_85/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_85" + op: "ConcatV2" + input: "compute_loss/zeros_8" + input: "compute_loss/Cos_14" + input: "compute_loss/Neg_14" + input: "compute_loss/concat_85/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_86/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_86" + op: "ConcatV2" + input: "compute_loss/zeros_8" + input: "compute_loss/Sin_14" + input: "compute_loss/Cos_14" + input: "compute_loss/concat_86/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_87/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_87" + op: "ConcatV2" + input: "compute_loss/concat_84" + input: "compute_loss/concat_85" + input: "compute_loss/concat_86" + input: "compute_loss/concat_87/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_28" + op: "BatchMatMul" + input: "compute_loss/concat_87" + input: "compute_loss/concat_83" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/MatMul_29" + op: "BatchMatMul" + input: "compute_loss/MatMul_28" + input: "compute_loss/concat_79" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Squeeze_9" + op: "Squeeze" + input: "compute_loss/MatMul_29" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 1 + } + } + } +} +node { + name: "compute_loss/Const_24" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "compute_loss/Tile_12/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_12" + op: "Tile" + input: "compute_loss/Const_24" + input: "compute_loss/Tile_12/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_88/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_88" + op: "ConcatV2" + input: "compute_loss/Squeeze_9" + input: "compute_loss/ExpandDims_40" + input: "compute_loss/concat_88/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_89/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_89" + op: "ConcatV2" + input: "compute_loss/concat_88" + input: "compute_loss/Tile_12" + input: "compute_loss/concat_89/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/stack_12" + 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\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_17/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: "compute_loss/ones_17" + op: "Fill" + input: "compute_loss/stack_12" + input: "compute_loss/ones_17/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/LinSpace_8/start" + 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: "compute_loss/LinSpace_8/stop" + 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: "compute_loss/LinSpace_8/num" + 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: 104 + } + } + } +} +node { + name: "compute_loss/LinSpace_8" + op: "LinSpace" + input: "compute_loss/LinSpace_8/start" + input: "compute_loss/LinSpace_8/stop" + input: "compute_loss/LinSpace_8/num" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_47/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: "compute_loss/ExpandDims_47" + op: "ExpandDims" + input: "compute_loss/LinSpace_8" + input: "compute_loss/ExpandDims_47/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/transpose_8/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/transpose_8" + op: "Transpose" + input: "compute_loss/ExpandDims_47" + input: "compute_loss/transpose_8/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_30" + op: "MatMul" + input: "compute_loss/ones_17" + input: "compute_loss/transpose_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/LinSpace_9/start" + 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: "compute_loss/LinSpace_9/stop" + 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: "compute_loss/LinSpace_9/num" + 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: 32 + } + } + } +} +node { + name: "compute_loss/LinSpace_9" + op: "LinSpace" + input: "compute_loss/LinSpace_9/start" + input: "compute_loss/LinSpace_9/stop" + input: "compute_loss/LinSpace_9/num" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_48/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: "compute_loss/ExpandDims_48" + op: "ExpandDims" + input: "compute_loss/LinSpace_9" + input: "compute_loss/ExpandDims_48/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/stack_13" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000h\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_18/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: "compute_loss/ones_18" + op: "Fill" + input: "compute_loss/stack_13" + input: "compute_loss/ones_18/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 104 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/MatMul_31" + op: "MatMul" + input: "compute_loss/ExpandDims_48" + input: "compute_loss/ones_18" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/add_32/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: 1.0 + } + } + } +} +node { + name: "compute_loss/add_32" + op: "Add" + input: "compute_loss/MatMul_30" + input: "compute_loss/add_32/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/mul_23/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } +} +node { + name: "compute_loss/mul_23" + op: "Mul" + input: "compute_loss/add_32" + input: "compute_loss/mul_23/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/Cast_8/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 103 + } + } + } +} +node { + name: "compute_loss/Cast_8" + op: "Cast" + input: "compute_loss/Cast_8/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul_24" + op: "Mul" + input: "compute_loss/mul_23" + input: "compute_loss/Cast_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/add_33/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: 1.0 + } + } + } +} +node { + name: "compute_loss/add_33" + op: "Add" + input: "compute_loss/MatMul_31" + input: "compute_loss/add_33/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/mul_25/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } +} +node { + name: "compute_loss/mul_25" + op: "Mul" + input: "compute_loss/add_33" + input: "compute_loss/mul_25/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/Cast_9/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 31 + } + } + } +} +node { + name: "compute_loss/Cast_9" + op: "Cast" + input: "compute_loss/Cast_9/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul_26" + op: "Mul" + input: "compute_loss/mul_25" + input: "compute_loss/Cast_9" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/ones_like_4/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: " \000\000\000h\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_like_4/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: "compute_loss/ones_like_4" + op: "Fill" + input: "compute_loss/ones_like_4/Shape" + input: "compute_loss/ones_like_4/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/stack_14" + op: "Pack" + input: "compute_loss/mul_24" + input: "compute_loss/mul_26" + input: "compute_loss/ones_like_4" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/ExpandDims_49/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: "compute_loss/ExpandDims_49" + op: "ExpandDims" + input: "compute_loss/stack_14" + input: "compute_loss/ExpandDims_49/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: 3 + } + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/Tile_13/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_13" + op: "Tile" + input: "compute_loss/ExpandDims_49" + input: "compute_loss/Tile_13/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_20/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_20" + op: "Reshape" + input: "compute_loss/Squeeze_8" + input: "compute_loss/Reshape_20/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_21/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_21" + op: "Reshape" + input: "compute_loss/Tile_13" + input: "compute_loss/Reshape_21/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/MatrixInverse_4" + op: "MatrixInverse" + input: "compute_loss/strided_slice_54" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adjoint" + value { + b: false + } + } +} +node { + name: "compute_loss/MatMul_32" + op: "BatchMatMul" + input: "compute_loss/MatrixInverse_4" + input: "compute_loss/Reshape_21" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3328 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/mul_27" + op: "Mul" + input: "compute_loss/MatMul_32" + input: "compute_loss/Reshape_20" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/ones_19/shape_as_tensor" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "compute_loss/ones_19/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: "compute_loss/ones_19" + op: "Fill" + input: "compute_loss/ones_19/shape_as_tensor" + input: "compute_loss/ones_19/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/concat_90/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_90" + op: "ConcatV2" + input: "compute_loss/mul_27" + input: "compute_loss/ones_19" + input: "compute_loss/concat_90/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_22/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\377\377\377\377 \000\000\000h\000\000\000" + } + } + } +} +node { + name: "compute_loss/Reshape_22" + op: "Reshape" + input: "compute_loss/concat_90" + input: "compute_loss/Reshape_22/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/Const_25" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "compute_loss/Tile_14/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_14" + op: "Tile" + input: "compute_loss/Const_25" + input: "compute_loss/Tile_14/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/zeros_9" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "compute_loss/concat_91/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_91" + op: "ConcatV2" + input: "compute_loss/strided_slice_54" + input: "compute_loss/zeros_9" + input: "compute_loss/concat_91/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_92/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_92" + op: "ConcatV2" + input: "compute_loss/concat_91" + input: "compute_loss/Tile_14" + input: "compute_loss/concat_92/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_33" + op: "BatchMatMul" + input: "compute_loss/concat_92" + input: "compute_loss/concat_89" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Reshape_23/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_23" + op: "Reshape" + input: "compute_loss/Reshape_22" + input: "compute_loss/Reshape_23/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_34" + op: "BatchMatMul" + input: "compute_loss/MatMul_33" + input: "compute_loss/Reshape_23" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Slice_32/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_32/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_32" + op: "Slice" + input: "compute_loss/MatMul_34" + input: "compute_loss/Slice_32/begin" + input: "compute_loss/Slice_32/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_33/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_33/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_33" + op: "Slice" + input: "compute_loss/MatMul_34" + input: "compute_loss/Slice_33/begin" + input: "compute_loss/Slice_33/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_34/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_34/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_34" + op: "Slice" + input: "compute_loss/MatMul_34" + input: "compute_loss/Slice_34/begin" + input: "compute_loss/Slice_34/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/add_34/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: 1.000000013351432e-10 + } + } + } +} +node { + name: "compute_loss/add_34" + op: "Add" + input: "compute_loss/Slice_34" + input: "compute_loss/add_34/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/truediv_8" + op: "RealDiv" + input: "compute_loss/Slice_32" + input: "compute_loss/add_34" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/add_35/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: 1.000000013351432e-10 + } + } + } +} +node { + name: "compute_loss/add_35" + op: "Add" + input: "compute_loss/Slice_34" + input: "compute_loss/add_35/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/truediv_9" + op: "RealDiv" + input: "compute_loss/Slice_33" + input: "compute_loss/add_35" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/concat_93/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_93" + op: "ConcatV2" + input: "compute_loss/truediv_8" + input: "compute_loss/truediv_9" + input: "compute_loss/concat_93/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_24/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\002\000\000\000 \000\000\000h\000\000\000" + } + } + } +} +node { + name: "compute_loss/Reshape_24" + op: "Reshape" + input: "compute_loss/concat_93" + input: "compute_loss/Reshape_24/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/transpose_9/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/transpose_9" + op: "Transpose" + input: "compute_loss/Reshape_24" + input: "compute_loss/transpose_9/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/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: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_4/split/split_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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_4/split" + op: "SplitV" + input: "compute_loss/transpose_9" + input: "compute_loss/image_sampling_4/Const" + input: "compute_loss/image_sampling_4/split/split_dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tlen" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "num_split" + value { + i: 2 + } + } +} +node { + name: "compute_loss/image_sampling_4/Floor" + op: "Floor" + input: "compute_loss/image_sampling_4/split" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/add/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_4/add" + op: "Add" + input: "compute_loss/image_sampling_4/Floor" + input: "compute_loss/image_sampling_4/add/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Floor_1" + op: "Floor" + input: "compute_loss/image_sampling_4/split:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/add_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: 1.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_4/add_1" + op: "Add" + input: "compute_loss/image_sampling_4/Floor_1" + input: "compute_loss/image_sampling_4/add_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_4/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: 1 + } + } + } +} +node { + name: "compute_loss/image_sampling_4/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: 2 + } + } + } +} +node { + name: "compute_loss/image_sampling_4/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: "compute_loss/image_sampling_4/strided_slice" + op: "StridedSlice" + input: "compute_loss/image_sampling_4/Shape" + input: "compute_loss/image_sampling_4/strided_slice/stack" + input: "compute_loss/image_sampling_4/strided_slice/stack_1" + input: "compute_loss/image_sampling_4/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: "compute_loss/image_sampling_4/sub/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/image_sampling_4/sub" + op: "Sub" + input: "compute_loss/image_sampling_4/strided_slice" + input: "compute_loss/image_sampling_4/sub/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Cast_2" + op: "Cast" + input: "compute_loss/image_sampling_4/sub" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_4/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: 2 + } + } + } +} +node { + name: "compute_loss/image_sampling_4/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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_4/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: "compute_loss/image_sampling_4/strided_slice_1" + op: "StridedSlice" + input: "compute_loss/image_sampling_4/Shape_1" + input: "compute_loss/image_sampling_4/strided_slice_1/stack" + input: "compute_loss/image_sampling_4/strided_slice_1/stack_1" + input: "compute_loss/image_sampling_4/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: "compute_loss/image_sampling_4/sub_1/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: "compute_loss/image_sampling_4/sub_1" + op: "Sub" + input: "compute_loss/image_sampling_4/strided_slice_1" + input: "compute_loss/image_sampling_4/sub_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Cast_3" + op: "Cast" + input: "compute_loss/image_sampling_4/sub_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/zeros" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_4/clip_by_value/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_4/Floor" + input: "compute_loss/image_sampling_4/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/clip_by_value" + op: "Maximum" + input: "compute_loss/image_sampling_4/clip_by_value/Minimum" + input: "compute_loss/image_sampling_4/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/clip_by_value_1/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_4/Floor_1" + input: "compute_loss/image_sampling_4/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/clip_by_value_1" + op: "Maximum" + input: "compute_loss/image_sampling_4/clip_by_value_1/Minimum" + input: "compute_loss/image_sampling_4/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/clip_by_value_2/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_4/add" + input: "compute_loss/image_sampling_4/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/clip_by_value_2" + op: "Maximum" + input: "compute_loss/image_sampling_4/clip_by_value_2/Minimum" + input: "compute_loss/image_sampling_4/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/clip_by_value_3/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_4/add_1" + input: "compute_loss/image_sampling_4/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/clip_by_value_3" + op: "Maximum" + input: "compute_loss/image_sampling_4/clip_by_value_3/Minimum" + input: "compute_loss/image_sampling_4/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/sub_2" + op: "Sub" + input: "compute_loss/image_sampling_4/clip_by_value_2" + input: "compute_loss/image_sampling_4/split" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/sub_3" + op: "Sub" + input: "compute_loss/image_sampling_4/split" + input: "compute_loss/image_sampling_4/clip_by_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/sub_4" + op: "Sub" + input: "compute_loss/image_sampling_4/clip_by_value_3" + input: "compute_loss/image_sampling_4/split:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/sub_5" + op: "Sub" + input: "compute_loss/image_sampling_4/split:1" + input: "compute_loss/image_sampling_4/clip_by_value_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Cast_4/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 104 + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Cast_4" + op: "Cast" + input: "compute_loss/image_sampling_4/Cast_4/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Cast_5/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3328 + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Cast_5" + op: "Cast" + input: "compute_loss/image_sampling_4/Cast_5/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/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: "compute_loss/image_sampling_4/range/limit" + 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: 4 + } + } + } +} +node { + name: "compute_loss/image_sampling_4/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: "compute_loss/image_sampling_4/range" + op: "Range" + input: "compute_loss/image_sampling_4/range/start" + input: "compute_loss/image_sampling_4/range/limit" + input: "compute_loss/image_sampling_4/range/delta" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Cast_6" + op: "Cast" + input: "compute_loss/image_sampling_4/range" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/mul" + op: "Mul" + input: "compute_loss/image_sampling_4/Cast_6" + input: "compute_loss/image_sampling_4/Cast_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/stack" + 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: 3328 + } + } + } +} +node { + name: "compute_loss/image_sampling_4/stack_1/values_0" + 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: 3328 + } + } + } +} +node { + name: "compute_loss/image_sampling_4/stack_1" + op: "Pack" + input: "compute_loss/image_sampling_4/stack_1/values_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: "compute_loss/image_sampling_4/ones/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: "compute_loss/image_sampling_4/ones" + op: "Fill" + input: "compute_loss/image_sampling_4/stack_1" + input: "compute_loss/image_sampling_4/ones/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3328 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/image_sampling_4/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: "compute_loss/image_sampling_4/ExpandDims" + op: "ExpandDims" + input: "compute_loss/image_sampling_4/ones" + input: "compute_loss/image_sampling_4/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: 3328 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/transpose/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_4/transpose" + op: "Transpose" + input: "compute_loss/image_sampling_4/ExpandDims" + input: "compute_loss/image_sampling_4/transpose/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Reshape" + op: "Reshape" + input: "compute_loss/image_sampling_4/mul" + input: "compute_loss/image_sampling_4/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: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/MatMul" + op: "MatMul" + input: "compute_loss/image_sampling_4/Reshape" + input: "compute_loss/image_sampling_4/transpose" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/image_sampling_4/Reshape_1/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -1 + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Reshape_1" + op: "Reshape" + input: "compute_loss/image_sampling_4/MatMul" + input: "compute_loss/image_sampling_4/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Reshape_2/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Reshape_2" + op: "Reshape" + input: "compute_loss/image_sampling_4/Reshape_1" + input: "compute_loss/image_sampling_4/Reshape_2/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/mul_1" + op: "Mul" + input: "compute_loss/image_sampling_4/clip_by_value_1" + input: "compute_loss/image_sampling_4/Cast_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/add_2" + op: "Add" + input: "compute_loss/image_sampling_4/Reshape_2" + input: "compute_loss/image_sampling_4/mul_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/mul_2" + op: "Mul" + input: "compute_loss/image_sampling_4/clip_by_value_3" + input: "compute_loss/image_sampling_4/Cast_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/add_3" + op: "Add" + input: "compute_loss/image_sampling_4/Reshape_2" + input: "compute_loss/image_sampling_4/mul_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/add_4" + op: "Add" + input: "compute_loss/image_sampling_4/clip_by_value" + input: "compute_loss/image_sampling_4/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Reshape_3/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: "compute_loss/image_sampling_4/Reshape_3" + op: "Reshape" + input: "compute_loss/image_sampling_4/add_4" + input: "compute_loss/image_sampling_4/Reshape_3/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/add_5" + op: "Add" + input: "compute_loss/image_sampling_4/clip_by_value" + input: "compute_loss/image_sampling_4/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/add_6" + op: "Add" + input: "compute_loss/image_sampling_4/clip_by_value_2" + input: "compute_loss/image_sampling_4/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/add_7" + op: "Add" + input: "compute_loss/image_sampling_4/clip_by_value_2" + input: "compute_loss/image_sampling_4/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/stack_2" + 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: "compute_loss/image_sampling_4/stack_3/values_0" + 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: "compute_loss/image_sampling_4/stack_3/values_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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_4/stack_3" + op: "Pack" + input: "compute_loss/image_sampling_4/stack_3/values_0" + input: "compute_loss/image_sampling_4/stack_3/values_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: "compute_loss/image_sampling_4/Reshape_4" + op: "Reshape" + input: "compute_loss/strided_slice_52" + input: "compute_loss/image_sampling_4/stack_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 13312 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Cast_9" + op: "Cast" + input: "compute_loss/image_sampling_4/Reshape_3" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/GatherV2/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: "compute_loss/image_sampling_4/GatherV2" + op: "GatherV2" + input: "compute_loss/image_sampling_4/Reshape_4" + input: "compute_loss/image_sampling_4/Cast_9" + input: "compute_loss/image_sampling_4/GatherV2/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 13312 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Reshape_5/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Reshape_5" + op: "Reshape" + input: "compute_loss/image_sampling_4/GatherV2" + input: "compute_loss/image_sampling_4/Reshape_5/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Cast_10" + op: "Cast" + input: "compute_loss/image_sampling_4/add_5" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/GatherV2_1/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: "compute_loss/image_sampling_4/GatherV2_1" + op: "GatherV2" + input: "compute_loss/image_sampling_4/Reshape_4" + input: "compute_loss/image_sampling_4/Cast_10" + input: "compute_loss/image_sampling_4/GatherV2_1/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Reshape_6/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Reshape_6" + op: "Reshape" + input: "compute_loss/image_sampling_4/GatherV2_1" + input: "compute_loss/image_sampling_4/Reshape_6/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Cast_11" + op: "Cast" + input: "compute_loss/image_sampling_4/add_6" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/GatherV2_2/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: "compute_loss/image_sampling_4/GatherV2_2" + op: "GatherV2" + input: "compute_loss/image_sampling_4/Reshape_4" + input: "compute_loss/image_sampling_4/Cast_11" + input: "compute_loss/image_sampling_4/GatherV2_2/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Reshape_7/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Reshape_7" + op: "Reshape" + input: "compute_loss/image_sampling_4/GatherV2_2" + input: "compute_loss/image_sampling_4/Reshape_7/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Cast_12" + op: "Cast" + input: "compute_loss/image_sampling_4/add_7" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/GatherV2_3/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: "compute_loss/image_sampling_4/GatherV2_3" + op: "GatherV2" + input: "compute_loss/image_sampling_4/Reshape_4" + input: "compute_loss/image_sampling_4/Cast_12" + input: "compute_loss/image_sampling_4/GatherV2_3/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Reshape_8/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_4/Reshape_8" + op: "Reshape" + input: "compute_loss/image_sampling_4/GatherV2_3" + input: "compute_loss/image_sampling_4/Reshape_8/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/mul_3" + op: "Mul" + input: "compute_loss/image_sampling_4/sub_2" + input: "compute_loss/image_sampling_4/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/mul_4" + op: "Mul" + input: "compute_loss/image_sampling_4/sub_2" + input: "compute_loss/image_sampling_4/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/mul_5" + op: "Mul" + input: "compute_loss/image_sampling_4/sub_3" + input: "compute_loss/image_sampling_4/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/mul_6" + op: "Mul" + input: "compute_loss/image_sampling_4/sub_3" + input: "compute_loss/image_sampling_4/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/mul_7" + op: "Mul" + input: "compute_loss/image_sampling_4/mul_3" + input: "compute_loss/image_sampling_4/Reshape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/mul_8" + op: "Mul" + input: "compute_loss/image_sampling_4/mul_4" + input: "compute_loss/image_sampling_4/Reshape_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/mul_9" + op: "Mul" + input: "compute_loss/image_sampling_4/mul_5" + input: "compute_loss/image_sampling_4/Reshape_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/mul_10" + op: "Mul" + input: "compute_loss/image_sampling_4/mul_6" + input: "compute_loss/image_sampling_4/Reshape_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_4/AddN" + op: "AddN" + input: "compute_loss/image_sampling_4/mul_7" + input: "compute_loss/image_sampling_4/mul_8" + input: "compute_loss/image_sampling_4/mul_9" + input: "compute_loss/image_sampling_4/mul_10" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/sub_22" + op: "Sub" + input: "compute_loss/image_sampling_4/AddN" + input: "compute_loss/ResizeArea_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Abs_16" + op: "Abs" + input: "compute_loss/sub_22" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Const_26" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_16" + op: "Mean" + input: "compute_loss/Abs_16" + input: "compute_loss/Const_26" + 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: "compute_loss/add_36" + op: "Add" + input: "compute_loss/add_27" + input: "compute_loss/Mean_16" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/strided_slice_56/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_56/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_56/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_56" + op: "StridedSlice" + input: "compute_loss/ResizeArea_5" + input: "compute_loss/strided_slice_56/stack" + input: "compute_loss/strided_slice_56/stack_1" + input: "compute_loss/strided_slice_56/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/Squeeze_10" + op: "Squeeze" + input: "depth_prediction/truediv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 3 + } + } + } +} +node { + name: "compute_loss/strided_slice_57/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_57/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_57/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_57" + op: "StridedSlice" + input: "pose_and_explainability_prediction/pose_exp_net/pose/mul" + input: "compute_loss/strided_slice_57/stack" + input: "compute_loss/strided_slice_57/stack_1" + input: "compute_loss/strided_slice_57/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 5 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 5 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "compute_loss/strided_slice_58/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_58/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\003\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_58/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_58" + op: "StridedSlice" + input: "data_loading/stack_19" + input: "compute_loss/strided_slice_58/stack" + input: "compute_loss/strided_slice_58/stack_1" + input: "compute_loss/strided_slice_58/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "compute_loss/Slice_35/begin" + 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\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_35/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_35" + op: "Slice" + input: "compute_loss/strided_slice_57" + input: "compute_loss/Slice_35/begin" + input: "compute_loss/Slice_35/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_50/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: "compute_loss/ExpandDims_50" + op: "ExpandDims" + input: "compute_loss/Slice_35" + input: "compute_loss/ExpandDims_50/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_36/begin" + 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\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_36/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_36" + op: "Slice" + input: "compute_loss/strided_slice_57" + input: "compute_loss/Slice_36/begin" + input: "compute_loss/Slice_36/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_37/begin" + 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\004\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_37/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_37" + op: "Slice" + input: "compute_loss/strided_slice_57" + input: "compute_loss/Slice_37/begin" + input: "compute_loss/Slice_37/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_38/begin" + 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\005\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_38/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_38" + op: "Slice" + input: "compute_loss/strided_slice_57" + input: "compute_loss/Slice_38/begin" + input: "compute_loss/Slice_38/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Shape_5" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_59/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: "compute_loss/strided_slice_59/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: "compute_loss/strided_slice_59/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: "compute_loss/strided_slice_59" + op: "StridedSlice" + input: "compute_loss/Shape_5" + input: "compute_loss/strided_slice_59/stack" + input: "compute_loss/strided_slice_59/stack_1" + input: "compute_loss/strided_slice_59/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: "compute_loss/clip_by_value_15/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_15/Minimum" + op: "Minimum" + input: "compute_loss/Slice_38" + input: "compute_loss/clip_by_value_15/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_15/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: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_15" + op: "Maximum" + input: "compute_loss/clip_by_value_15/Minimum" + input: "compute_loss/clip_by_value_15/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_16/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_16/Minimum" + op: "Minimum" + input: "compute_loss/Slice_37" + input: "compute_loss/clip_by_value_16/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_16/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: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_16" + op: "Maximum" + input: "compute_loss/clip_by_value_16/Minimum" + input: "compute_loss/clip_by_value_16/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_17/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_17/Minimum" + op: "Minimum" + input: "compute_loss/Slice_36" + input: "compute_loss/clip_by_value_17/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_17/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: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_17" + op: "Maximum" + input: "compute_loss/clip_by_value_17/Minimum" + input: "compute_loss/clip_by_value_17/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_51/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: "compute_loss/ExpandDims_51" + op: "ExpandDims" + input: "compute_loss/clip_by_value_15" + input: "compute_loss/ExpandDims_51/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_52/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: "compute_loss/ExpandDims_52" + op: "ExpandDims" + input: "compute_loss/ExpandDims_51" + input: "compute_loss/ExpandDims_52/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_53/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: "compute_loss/ExpandDims_53" + op: "ExpandDims" + input: "compute_loss/clip_by_value_16" + input: "compute_loss/ExpandDims_53/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_54/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: "compute_loss/ExpandDims_54" + op: "ExpandDims" + input: "compute_loss/ExpandDims_53" + input: "compute_loss/ExpandDims_54/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_55/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: "compute_loss/ExpandDims_55" + op: "ExpandDims" + input: "compute_loss/clip_by_value_17" + input: "compute_loss/ExpandDims_55/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_56/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: "compute_loss/ExpandDims_56" + op: "ExpandDims" + input: "compute_loss/ExpandDims_55" + input: "compute_loss/ExpandDims_56/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/zeros_10/mul/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: "compute_loss/zeros_10/mul" + op: "Mul" + input: "compute_loss/strided_slice_59" + input: "compute_loss/zeros_10/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_10/mul_1/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: "compute_loss/zeros_10/mul_1" + op: "Mul" + input: "compute_loss/zeros_10/mul" + input: "compute_loss/zeros_10/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_10/mul_2/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: "compute_loss/zeros_10/mul_2" + op: "Mul" + input: "compute_loss/zeros_10/mul_1" + input: "compute_loss/zeros_10/mul_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_10/Less/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: 1000 + } + } + } +} +node { + name: "compute_loss/zeros_10/Less" + op: "Less" + input: "compute_loss/zeros_10/mul_2" + input: "compute_loss/zeros_10/Less/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_10/packed/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: "compute_loss/zeros_10/packed/2" + 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: "compute_loss/zeros_10/packed/3" + 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: "compute_loss/zeros_10/packed" + op: "Pack" + input: "compute_loss/strided_slice_59" + input: "compute_loss/zeros_10/packed/1" + input: "compute_loss/zeros_10/packed/2" + input: "compute_loss/zeros_10/packed/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/zeros_10/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: 0.0 + } + } + } +} +node { + name: "compute_loss/zeros_10" + op: "Fill" + input: "compute_loss/zeros_10/packed" + input: "compute_loss/zeros_10/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/ones_20/mul/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: "compute_loss/ones_20/mul" + op: "Mul" + input: "compute_loss/strided_slice_59" + input: "compute_loss/ones_20/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_20/mul_1/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: "compute_loss/ones_20/mul_1" + op: "Mul" + input: "compute_loss/ones_20/mul" + input: "compute_loss/ones_20/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_20/mul_2/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: "compute_loss/ones_20/mul_2" + op: "Mul" + input: "compute_loss/ones_20/mul_1" + input: "compute_loss/ones_20/mul_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_20/Less/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: 1000 + } + } + } +} +node { + name: "compute_loss/ones_20/Less" + op: "Less" + input: "compute_loss/ones_20/mul_2" + input: "compute_loss/ones_20/Less/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_20/packed/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: "compute_loss/ones_20/packed/2" + 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: "compute_loss/ones_20/packed/3" + 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: "compute_loss/ones_20/packed" + op: "Pack" + input: "compute_loss/strided_slice_59" + input: "compute_loss/ones_20/packed/1" + input: "compute_loss/ones_20/packed/2" + input: "compute_loss/ones_20/packed/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/ones_20/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: "compute_loss/ones_20" + op: "Fill" + input: "compute_loss/ones_20/packed" + input: "compute_loss/ones_20/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/Cos_15" + op: "Cos" + input: "compute_loss/ExpandDims_52" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_15" + op: "Sin" + input: "compute_loss/ExpandDims_52" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_15" + op: "Neg" + input: "compute_loss/Sin_15" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_94/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_94" + op: "ConcatV2" + input: "compute_loss/Cos_15" + input: "compute_loss/Neg_15" + input: "compute_loss/zeros_10" + input: "compute_loss/concat_94/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_95/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_95" + op: "ConcatV2" + input: "compute_loss/Sin_15" + input: "compute_loss/Cos_15" + input: "compute_loss/zeros_10" + input: "compute_loss/concat_95/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_96/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_96" + op: "ConcatV2" + input: "compute_loss/zeros_10" + input: "compute_loss/zeros_10" + input: "compute_loss/ones_20" + input: "compute_loss/concat_96/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_97/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_97" + op: "ConcatV2" + input: "compute_loss/concat_94" + input: "compute_loss/concat_95" + input: "compute_loss/concat_96" + input: "compute_loss/concat_97/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Cos_16" + op: "Cos" + input: "compute_loss/ExpandDims_54" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_16" + op: "Sin" + input: "compute_loss/ExpandDims_54" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_98/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_98" + op: "ConcatV2" + input: "compute_loss/Cos_16" + input: "compute_loss/zeros_10" + input: "compute_loss/Sin_16" + input: "compute_loss/concat_98/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_99/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_99" + op: "ConcatV2" + input: "compute_loss/zeros_10" + input: "compute_loss/ones_20" + input: "compute_loss/zeros_10" + input: "compute_loss/concat_99/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_16" + op: "Neg" + input: "compute_loss/Sin_16" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_100/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_100" + op: "ConcatV2" + input: "compute_loss/Neg_16" + input: "compute_loss/zeros_10" + input: "compute_loss/Cos_16" + input: "compute_loss/concat_100/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_101/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_101" + op: "ConcatV2" + input: "compute_loss/concat_98" + input: "compute_loss/concat_99" + input: "compute_loss/concat_100" + input: "compute_loss/concat_101/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Cos_17" + op: "Cos" + input: "compute_loss/ExpandDims_56" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_17" + op: "Sin" + input: "compute_loss/ExpandDims_56" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_102/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_102" + op: "ConcatV2" + input: "compute_loss/ones_20" + input: "compute_loss/zeros_10" + input: "compute_loss/zeros_10" + input: "compute_loss/concat_102/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_17" + op: "Neg" + input: "compute_loss/Sin_17" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_103/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_103" + op: "ConcatV2" + input: "compute_loss/zeros_10" + input: "compute_loss/Cos_17" + input: "compute_loss/Neg_17" + input: "compute_loss/concat_103/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_104/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_104" + op: "ConcatV2" + input: "compute_loss/zeros_10" + input: "compute_loss/Sin_17" + input: "compute_loss/Cos_17" + input: "compute_loss/concat_104/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_105/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_105" + op: "ConcatV2" + input: "compute_loss/concat_102" + input: "compute_loss/concat_103" + input: "compute_loss/concat_104" + input: "compute_loss/concat_105/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_35" + op: "BatchMatMul" + input: "compute_loss/concat_105" + input: "compute_loss/concat_101" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/MatMul_36" + op: "BatchMatMul" + input: "compute_loss/MatMul_35" + input: "compute_loss/concat_97" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Squeeze_11" + op: "Squeeze" + input: "compute_loss/MatMul_36" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 1 + } + } + } +} +node { + name: "compute_loss/Const_27" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "compute_loss/Tile_15/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_15" + op: "Tile" + input: "compute_loss/Const_27" + input: "compute_loss/Tile_15/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_106/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_106" + op: "ConcatV2" + input: "compute_loss/Squeeze_11" + input: "compute_loss/ExpandDims_50" + input: "compute_loss/concat_106/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_107/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_107" + op: "ConcatV2" + input: "compute_loss/concat_106" + input: "compute_loss/Tile_15" + input: "compute_loss/concat_107/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/stack_15" + 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\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_21/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: "compute_loss/ones_21" + op: "Fill" + input: "compute_loss/stack_15" + input: "compute_loss/ones_21/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/LinSpace_10/start" + 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: "compute_loss/LinSpace_10/stop" + 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: "compute_loss/LinSpace_10/num" + 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: 104 + } + } + } +} +node { + name: "compute_loss/LinSpace_10" + op: "LinSpace" + input: "compute_loss/LinSpace_10/start" + input: "compute_loss/LinSpace_10/stop" + input: "compute_loss/LinSpace_10/num" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_57/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: "compute_loss/ExpandDims_57" + op: "ExpandDims" + input: "compute_loss/LinSpace_10" + input: "compute_loss/ExpandDims_57/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/transpose_10/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/transpose_10" + op: "Transpose" + input: "compute_loss/ExpandDims_57" + input: "compute_loss/transpose_10/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_37" + op: "MatMul" + input: "compute_loss/ones_21" + input: "compute_loss/transpose_10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/LinSpace_11/start" + 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: "compute_loss/LinSpace_11/stop" + 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: "compute_loss/LinSpace_11/num" + 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: 32 + } + } + } +} +node { + name: "compute_loss/LinSpace_11" + op: "LinSpace" + input: "compute_loss/LinSpace_11/start" + input: "compute_loss/LinSpace_11/stop" + input: "compute_loss/LinSpace_11/num" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_58/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: "compute_loss/ExpandDims_58" + op: "ExpandDims" + input: "compute_loss/LinSpace_11" + input: "compute_loss/ExpandDims_58/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/stack_16" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000h\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_22/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: "compute_loss/ones_22" + op: "Fill" + input: "compute_loss/stack_16" + input: "compute_loss/ones_22/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 104 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/MatMul_38" + op: "MatMul" + input: "compute_loss/ExpandDims_58" + input: "compute_loss/ones_22" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/add_37/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: 1.0 + } + } + } +} +node { + name: "compute_loss/add_37" + op: "Add" + input: "compute_loss/MatMul_37" + input: "compute_loss/add_37/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/mul_28/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } +} +node { + name: "compute_loss/mul_28" + op: "Mul" + input: "compute_loss/add_37" + input: "compute_loss/mul_28/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/Cast_10/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 103 + } + } + } +} +node { + name: "compute_loss/Cast_10" + op: "Cast" + input: "compute_loss/Cast_10/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul_29" + op: "Mul" + input: "compute_loss/mul_28" + input: "compute_loss/Cast_10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/add_38/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: 1.0 + } + } + } +} +node { + name: "compute_loss/add_38" + op: "Add" + input: "compute_loss/MatMul_38" + input: "compute_loss/add_38/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/mul_30/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } +} +node { + name: "compute_loss/mul_30" + op: "Mul" + input: "compute_loss/add_38" + input: "compute_loss/mul_30/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/Cast_11/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 31 + } + } + } +} +node { + name: "compute_loss/Cast_11" + op: "Cast" + input: "compute_loss/Cast_11/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul_31" + op: "Mul" + input: "compute_loss/mul_30" + input: "compute_loss/Cast_11" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/ones_like_5/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: " \000\000\000h\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_like_5/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: "compute_loss/ones_like_5" + op: "Fill" + input: "compute_loss/ones_like_5/Shape" + input: "compute_loss/ones_like_5/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/stack_17" + op: "Pack" + input: "compute_loss/mul_29" + input: "compute_loss/mul_31" + input: "compute_loss/ones_like_5" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/ExpandDims_59/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: "compute_loss/ExpandDims_59" + op: "ExpandDims" + input: "compute_loss/stack_17" + input: "compute_loss/ExpandDims_59/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: 3 + } + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/Tile_16/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_16" + op: "Tile" + input: "compute_loss/ExpandDims_59" + input: "compute_loss/Tile_16/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_25/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_25" + op: "Reshape" + input: "compute_loss/Squeeze_10" + input: "compute_loss/Reshape_25/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_26/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_26" + op: "Reshape" + input: "compute_loss/Tile_16" + input: "compute_loss/Reshape_26/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/MatrixInverse_5" + op: "MatrixInverse" + input: "compute_loss/strided_slice_58" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adjoint" + value { + b: false + } + } +} +node { + name: "compute_loss/MatMul_39" + op: "BatchMatMul" + input: "compute_loss/MatrixInverse_5" + input: "compute_loss/Reshape_26" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3328 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/mul_32" + op: "Mul" + input: "compute_loss/MatMul_39" + input: "compute_loss/Reshape_25" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/ones_23/shape_as_tensor" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "compute_loss/ones_23/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: "compute_loss/ones_23" + op: "Fill" + input: "compute_loss/ones_23/shape_as_tensor" + input: "compute_loss/ones_23/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/concat_108/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_108" + op: "ConcatV2" + input: "compute_loss/mul_32" + input: "compute_loss/ones_23" + input: "compute_loss/concat_108/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_27/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\377\377\377\377 \000\000\000h\000\000\000" + } + } + } +} +node { + name: "compute_loss/Reshape_27" + op: "Reshape" + input: "compute_loss/concat_108" + input: "compute_loss/Reshape_27/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/Const_28" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "compute_loss/Tile_17/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_17" + op: "Tile" + input: "compute_loss/Const_28" + input: "compute_loss/Tile_17/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/zeros_11" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "compute_loss/concat_109/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_109" + op: "ConcatV2" + input: "compute_loss/strided_slice_58" + input: "compute_loss/zeros_11" + input: "compute_loss/concat_109/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_110/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_110" + op: "ConcatV2" + input: "compute_loss/concat_109" + input: "compute_loss/Tile_17" + input: "compute_loss/concat_110/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_40" + op: "BatchMatMul" + input: "compute_loss/concat_110" + input: "compute_loss/concat_107" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Reshape_28/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_28" + op: "Reshape" + input: "compute_loss/Reshape_27" + input: "compute_loss/Reshape_28/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_41" + op: "BatchMatMul" + input: "compute_loss/MatMul_40" + input: "compute_loss/Reshape_28" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Slice_39/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_39/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_39" + op: "Slice" + input: "compute_loss/MatMul_41" + input: "compute_loss/Slice_39/begin" + input: "compute_loss/Slice_39/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_40/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_40/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_40" + op: "Slice" + input: "compute_loss/MatMul_41" + input: "compute_loss/Slice_40/begin" + input: "compute_loss/Slice_40/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_41/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_41/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_41" + op: "Slice" + input: "compute_loss/MatMul_41" + input: "compute_loss/Slice_41/begin" + input: "compute_loss/Slice_41/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/add_39/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: 1.000000013351432e-10 + } + } + } +} +node { + name: "compute_loss/add_39" + op: "Add" + input: "compute_loss/Slice_41" + input: "compute_loss/add_39/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/truediv_10" + op: "RealDiv" + input: "compute_loss/Slice_39" + input: "compute_loss/add_39" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/add_40/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: 1.000000013351432e-10 + } + } + } +} +node { + name: "compute_loss/add_40" + op: "Add" + input: "compute_loss/Slice_41" + input: "compute_loss/add_40/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/truediv_11" + op: "RealDiv" + input: "compute_loss/Slice_40" + input: "compute_loss/add_40" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/concat_111/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_111" + op: "ConcatV2" + input: "compute_loss/truediv_10" + input: "compute_loss/truediv_11" + input: "compute_loss/concat_111/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_29/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\002\000\000\000 \000\000\000h\000\000\000" + } + } + } +} +node { + name: "compute_loss/Reshape_29" + op: "Reshape" + input: "compute_loss/concat_111" + input: "compute_loss/Reshape_29/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "compute_loss/transpose_11/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/transpose_11" + op: "Transpose" + input: "compute_loss/Reshape_29" + input: "compute_loss/transpose_11/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/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: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_5/split/split_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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_5/split" + op: "SplitV" + input: "compute_loss/transpose_11" + input: "compute_loss/image_sampling_5/Const" + input: "compute_loss/image_sampling_5/split/split_dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tlen" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "num_split" + value { + i: 2 + } + } +} +node { + name: "compute_loss/image_sampling_5/Floor" + op: "Floor" + input: "compute_loss/image_sampling_5/split" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/add/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_5/add" + op: "Add" + input: "compute_loss/image_sampling_5/Floor" + input: "compute_loss/image_sampling_5/add/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Floor_1" + op: "Floor" + input: "compute_loss/image_sampling_5/split:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/add_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: 1.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_5/add_1" + op: "Add" + input: "compute_loss/image_sampling_5/Floor_1" + input: "compute_loss/image_sampling_5/add_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_5/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: 1 + } + } + } +} +node { + name: "compute_loss/image_sampling_5/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: 2 + } + } + } +} +node { + name: "compute_loss/image_sampling_5/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: "compute_loss/image_sampling_5/strided_slice" + op: "StridedSlice" + input: "compute_loss/image_sampling_5/Shape" + input: "compute_loss/image_sampling_5/strided_slice/stack" + input: "compute_loss/image_sampling_5/strided_slice/stack_1" + input: "compute_loss/image_sampling_5/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: "compute_loss/image_sampling_5/sub/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/image_sampling_5/sub" + op: "Sub" + input: "compute_loss/image_sampling_5/strided_slice" + input: "compute_loss/image_sampling_5/sub/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Cast_2" + op: "Cast" + input: "compute_loss/image_sampling_5/sub" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_5/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: 2 + } + } + } +} +node { + name: "compute_loss/image_sampling_5/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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_5/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: "compute_loss/image_sampling_5/strided_slice_1" + op: "StridedSlice" + input: "compute_loss/image_sampling_5/Shape_1" + input: "compute_loss/image_sampling_5/strided_slice_1/stack" + input: "compute_loss/image_sampling_5/strided_slice_1/stack_1" + input: "compute_loss/image_sampling_5/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: "compute_loss/image_sampling_5/sub_1/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: "compute_loss/image_sampling_5/sub_1" + op: "Sub" + input: "compute_loss/image_sampling_5/strided_slice_1" + input: "compute_loss/image_sampling_5/sub_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Cast_3" + op: "Cast" + input: "compute_loss/image_sampling_5/sub_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/zeros" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_5/clip_by_value/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_5/Floor" + input: "compute_loss/image_sampling_5/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/clip_by_value" + op: "Maximum" + input: "compute_loss/image_sampling_5/clip_by_value/Minimum" + input: "compute_loss/image_sampling_5/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/clip_by_value_1/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_5/Floor_1" + input: "compute_loss/image_sampling_5/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/clip_by_value_1" + op: "Maximum" + input: "compute_loss/image_sampling_5/clip_by_value_1/Minimum" + input: "compute_loss/image_sampling_5/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/clip_by_value_2/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_5/add" + input: "compute_loss/image_sampling_5/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/clip_by_value_2" + op: "Maximum" + input: "compute_loss/image_sampling_5/clip_by_value_2/Minimum" + input: "compute_loss/image_sampling_5/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/clip_by_value_3/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_5/add_1" + input: "compute_loss/image_sampling_5/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/clip_by_value_3" + op: "Maximum" + input: "compute_loss/image_sampling_5/clip_by_value_3/Minimum" + input: "compute_loss/image_sampling_5/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/sub_2" + op: "Sub" + input: "compute_loss/image_sampling_5/clip_by_value_2" + input: "compute_loss/image_sampling_5/split" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/sub_3" + op: "Sub" + input: "compute_loss/image_sampling_5/split" + input: "compute_loss/image_sampling_5/clip_by_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/sub_4" + op: "Sub" + input: "compute_loss/image_sampling_5/clip_by_value_3" + input: "compute_loss/image_sampling_5/split:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/sub_5" + op: "Sub" + input: "compute_loss/image_sampling_5/split:1" + input: "compute_loss/image_sampling_5/clip_by_value_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Cast_4/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 104 + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Cast_4" + op: "Cast" + input: "compute_loss/image_sampling_5/Cast_4/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Cast_5/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3328 + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Cast_5" + op: "Cast" + input: "compute_loss/image_sampling_5/Cast_5/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/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: "compute_loss/image_sampling_5/range/limit" + 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: 4 + } + } + } +} +node { + name: "compute_loss/image_sampling_5/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: "compute_loss/image_sampling_5/range" + op: "Range" + input: "compute_loss/image_sampling_5/range/start" + input: "compute_loss/image_sampling_5/range/limit" + input: "compute_loss/image_sampling_5/range/delta" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Cast_6" + op: "Cast" + input: "compute_loss/image_sampling_5/range" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/mul" + op: "Mul" + input: "compute_loss/image_sampling_5/Cast_6" + input: "compute_loss/image_sampling_5/Cast_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/stack" + 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: 3328 + } + } + } +} +node { + name: "compute_loss/image_sampling_5/stack_1/values_0" + 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: 3328 + } + } + } +} +node { + name: "compute_loss/image_sampling_5/stack_1" + op: "Pack" + input: "compute_loss/image_sampling_5/stack_1/values_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: "compute_loss/image_sampling_5/ones/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: "compute_loss/image_sampling_5/ones" + op: "Fill" + input: "compute_loss/image_sampling_5/stack_1" + input: "compute_loss/image_sampling_5/ones/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3328 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/image_sampling_5/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: "compute_loss/image_sampling_5/ExpandDims" + op: "ExpandDims" + input: "compute_loss/image_sampling_5/ones" + input: "compute_loss/image_sampling_5/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: 3328 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/transpose/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_5/transpose" + op: "Transpose" + input: "compute_loss/image_sampling_5/ExpandDims" + input: "compute_loss/image_sampling_5/transpose/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Reshape" + op: "Reshape" + input: "compute_loss/image_sampling_5/mul" + input: "compute_loss/image_sampling_5/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: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/MatMul" + op: "MatMul" + input: "compute_loss/image_sampling_5/Reshape" + input: "compute_loss/image_sampling_5/transpose" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/image_sampling_5/Reshape_1/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -1 + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Reshape_1" + op: "Reshape" + input: "compute_loss/image_sampling_5/MatMul" + input: "compute_loss/image_sampling_5/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Reshape_2/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Reshape_2" + op: "Reshape" + input: "compute_loss/image_sampling_5/Reshape_1" + input: "compute_loss/image_sampling_5/Reshape_2/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/mul_1" + op: "Mul" + input: "compute_loss/image_sampling_5/clip_by_value_1" + input: "compute_loss/image_sampling_5/Cast_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/add_2" + op: "Add" + input: "compute_loss/image_sampling_5/Reshape_2" + input: "compute_loss/image_sampling_5/mul_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/mul_2" + op: "Mul" + input: "compute_loss/image_sampling_5/clip_by_value_3" + input: "compute_loss/image_sampling_5/Cast_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/add_3" + op: "Add" + input: "compute_loss/image_sampling_5/Reshape_2" + input: "compute_loss/image_sampling_5/mul_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/add_4" + op: "Add" + input: "compute_loss/image_sampling_5/clip_by_value" + input: "compute_loss/image_sampling_5/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Reshape_3/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: "compute_loss/image_sampling_5/Reshape_3" + op: "Reshape" + input: "compute_loss/image_sampling_5/add_4" + input: "compute_loss/image_sampling_5/Reshape_3/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/add_5" + op: "Add" + input: "compute_loss/image_sampling_5/clip_by_value" + input: "compute_loss/image_sampling_5/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/add_6" + op: "Add" + input: "compute_loss/image_sampling_5/clip_by_value_2" + input: "compute_loss/image_sampling_5/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/add_7" + op: "Add" + input: "compute_loss/image_sampling_5/clip_by_value_2" + input: "compute_loss/image_sampling_5/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/stack_2" + 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: "compute_loss/image_sampling_5/stack_3/values_0" + 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: "compute_loss/image_sampling_5/stack_3/values_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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_5/stack_3" + op: "Pack" + input: "compute_loss/image_sampling_5/stack_3/values_0" + input: "compute_loss/image_sampling_5/stack_3/values_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: "compute_loss/image_sampling_5/Reshape_4" + op: "Reshape" + input: "compute_loss/strided_slice_56" + input: "compute_loss/image_sampling_5/stack_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 13312 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Cast_9" + op: "Cast" + input: "compute_loss/image_sampling_5/Reshape_3" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/GatherV2/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: "compute_loss/image_sampling_5/GatherV2" + op: "GatherV2" + input: "compute_loss/image_sampling_5/Reshape_4" + input: "compute_loss/image_sampling_5/Cast_9" + input: "compute_loss/image_sampling_5/GatherV2/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 13312 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Reshape_5/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Reshape_5" + op: "Reshape" + input: "compute_loss/image_sampling_5/GatherV2" + input: "compute_loss/image_sampling_5/Reshape_5/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Cast_10" + op: "Cast" + input: "compute_loss/image_sampling_5/add_5" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/GatherV2_1/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: "compute_loss/image_sampling_5/GatherV2_1" + op: "GatherV2" + input: "compute_loss/image_sampling_5/Reshape_4" + input: "compute_loss/image_sampling_5/Cast_10" + input: "compute_loss/image_sampling_5/GatherV2_1/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Reshape_6/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Reshape_6" + op: "Reshape" + input: "compute_loss/image_sampling_5/GatherV2_1" + input: "compute_loss/image_sampling_5/Reshape_6/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Cast_11" + op: "Cast" + input: "compute_loss/image_sampling_5/add_6" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/GatherV2_2/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: "compute_loss/image_sampling_5/GatherV2_2" + op: "GatherV2" + input: "compute_loss/image_sampling_5/Reshape_4" + input: "compute_loss/image_sampling_5/Cast_11" + input: "compute_loss/image_sampling_5/GatherV2_2/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Reshape_7/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Reshape_7" + op: "Reshape" + input: "compute_loss/image_sampling_5/GatherV2_2" + input: "compute_loss/image_sampling_5/Reshape_7/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Cast_12" + op: "Cast" + input: "compute_loss/image_sampling_5/add_7" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/GatherV2_3/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: "compute_loss/image_sampling_5/GatherV2_3" + op: "GatherV2" + input: "compute_loss/image_sampling_5/Reshape_4" + input: "compute_loss/image_sampling_5/Cast_12" + input: "compute_loss/image_sampling_5/GatherV2_3/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Reshape_8/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_5/Reshape_8" + op: "Reshape" + input: "compute_loss/image_sampling_5/GatherV2_3" + input: "compute_loss/image_sampling_5/Reshape_8/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/mul_3" + op: "Mul" + input: "compute_loss/image_sampling_5/sub_2" + input: "compute_loss/image_sampling_5/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/mul_4" + op: "Mul" + input: "compute_loss/image_sampling_5/sub_2" + input: "compute_loss/image_sampling_5/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/mul_5" + op: "Mul" + input: "compute_loss/image_sampling_5/sub_3" + input: "compute_loss/image_sampling_5/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/mul_6" + op: "Mul" + input: "compute_loss/image_sampling_5/sub_3" + input: "compute_loss/image_sampling_5/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/mul_7" + op: "Mul" + input: "compute_loss/image_sampling_5/mul_3" + input: "compute_loss/image_sampling_5/Reshape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/mul_8" + op: "Mul" + input: "compute_loss/image_sampling_5/mul_4" + input: "compute_loss/image_sampling_5/Reshape_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/mul_9" + op: "Mul" + input: "compute_loss/image_sampling_5/mul_5" + input: "compute_loss/image_sampling_5/Reshape_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/mul_10" + op: "Mul" + input: "compute_loss/image_sampling_5/mul_6" + input: "compute_loss/image_sampling_5/Reshape_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_5/AddN" + op: "AddN" + input: "compute_loss/image_sampling_5/mul_7" + input: "compute_loss/image_sampling_5/mul_8" + input: "compute_loss/image_sampling_5/mul_9" + input: "compute_loss/image_sampling_5/mul_10" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/sub_23" + op: "Sub" + input: "compute_loss/image_sampling_5/AddN" + input: "compute_loss/ResizeArea_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Abs_17" + op: "Abs" + input: "compute_loss/sub_23" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Const_29" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_17" + op: "Mean" + input: "compute_loss/Abs_17" + input: "compute_loss/Const_29" + 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: "compute_loss/add_41" + op: "Add" + input: "compute_loss/add_36" + input: "compute_loss/Mean_17" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/concat_112/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_112" + op: "ConcatV2" + input: "compute_loss/image_sampling_4/AddN" + input: "compute_loss/image_sampling_5/AddN" + input: "compute_loss/concat_112/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "compute_loss/concat_113/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_113" + op: "ConcatV2" + input: "compute_loss/Abs_16" + input: "compute_loss/Abs_17" + input: "compute_loss/concat_113/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "compute_loss/ResizeArea_6/size" + 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: "\020\000\000\0004\000\000\000" + } + } + } +} +node { + name: "compute_loss/ResizeArea_6" + op: "ResizeArea" + input: "data_loading/sub_4" + input: "compute_loss/ResizeArea_6/size" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "align_corners" + value { + b: false + } + } +} +node { + name: "compute_loss/ResizeArea_7/size" + 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: "\020\000\000\0004\000\000\000" + } + } + } +} +node { + name: "compute_loss/ResizeArea_7" + op: "ResizeArea" + input: "data_loading/sub_5" + input: "compute_loss/ResizeArea_7/size" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "align_corners" + value { + b: false + } + } +} +node { + name: "compute_loss/strided_slice_60/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_60/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_60/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_60" + op: "StridedSlice" + input: "depth_prediction/depth_net/add" + input: "compute_loss/strided_slice_60/stack" + input: "compute_loss/strided_slice_60/stack_1" + input: "compute_loss/strided_slice_60/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_61/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_61/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\377\377\377\377\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_61/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_61" + op: "StridedSlice" + input: "depth_prediction/depth_net/add" + input: "compute_loss/strided_slice_61/stack" + input: "compute_loss/strided_slice_61/stack_1" + input: "compute_loss/strided_slice_61/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_24" + op: "Sub" + input: "compute_loss/strided_slice_60" + input: "compute_loss/strided_slice_61" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_62/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_62/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_62/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_62" + op: "StridedSlice" + input: "depth_prediction/depth_net/add" + input: "compute_loss/strided_slice_62/stack" + input: "compute_loss/strided_slice_62/stack_1" + input: "compute_loss/strided_slice_62/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_63/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_63/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\377\377\377\377\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_63/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_63" + op: "StridedSlice" + input: "depth_prediction/depth_net/add" + input: "compute_loss/strided_slice_63/stack" + input: "compute_loss/strided_slice_63/stack_1" + input: "compute_loss/strided_slice_63/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_25" + op: "Sub" + input: "compute_loss/strided_slice_62" + input: "compute_loss/strided_slice_63" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_64/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_64/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_64/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_64" + op: "StridedSlice" + input: "compute_loss/sub_25" + input: "compute_loss/strided_slice_64/stack" + input: "compute_loss/strided_slice_64/stack_1" + input: "compute_loss/strided_slice_64/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_65/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_65/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\377\377\377\377\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_65/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_65" + op: "StridedSlice" + input: "compute_loss/sub_25" + input: "compute_loss/strided_slice_65/stack" + input: "compute_loss/strided_slice_65/stack_1" + input: "compute_loss/strided_slice_65/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_26" + op: "Sub" + input: "compute_loss/strided_slice_64" + input: "compute_loss/strided_slice_65" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_66/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_66/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_66/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_66" + op: "StridedSlice" + input: "compute_loss/sub_25" + input: "compute_loss/strided_slice_66/stack" + input: "compute_loss/strided_slice_66/stack_1" + input: "compute_loss/strided_slice_66/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 50 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_67/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_67/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\377\377\377\377\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_67/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_67" + op: "StridedSlice" + input: "compute_loss/sub_25" + input: "compute_loss/strided_slice_67/stack" + input: "compute_loss/strided_slice_67/stack_1" + input: "compute_loss/strided_slice_67/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 50 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_27" + op: "Sub" + input: "compute_loss/strided_slice_66" + input: "compute_loss/strided_slice_67" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 50 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_68/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_68/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_68/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_68" + op: "StridedSlice" + input: "compute_loss/sub_24" + input: "compute_loss/strided_slice_68/stack" + input: "compute_loss/strided_slice_68/stack_1" + input: "compute_loss/strided_slice_68/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 14 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_69/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_69/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\377\377\377\377\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_69/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_69" + op: "StridedSlice" + input: "compute_loss/sub_24" + input: "compute_loss/strided_slice_69/stack" + input: "compute_loss/strided_slice_69/stack_1" + input: "compute_loss/strided_slice_69/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 14 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_28" + op: "Sub" + input: "compute_loss/strided_slice_68" + input: "compute_loss/strided_slice_69" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 14 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/strided_slice_70/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_70/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_70/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_70" + op: "StridedSlice" + input: "compute_loss/sub_24" + input: "compute_loss/strided_slice_70/stack" + input: "compute_loss/strided_slice_70/stack_1" + input: "compute_loss/strided_slice_70/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/strided_slice_71/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_71/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\377\377\377\377\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_71/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_71" + op: "StridedSlice" + input: "compute_loss/sub_24" + input: "compute_loss/strided_slice_71/stack" + input: "compute_loss/strided_slice_71/stack_1" + input: "compute_loss/strided_slice_71/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/sub_29" + op: "Sub" + input: "compute_loss/strided_slice_70" + input: "compute_loss/strided_slice_71" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Abs_18" + op: "Abs" + input: "compute_loss/sub_27" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 50 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Const_30" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_18" + op: "Mean" + input: "compute_loss/Abs_18" + input: "compute_loss/Const_30" + 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: "compute_loss/Abs_19" + op: "Abs" + input: "compute_loss/sub_26" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Const_31" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_19" + op: "Mean" + input: "compute_loss/Abs_19" + input: "compute_loss/Const_31" + 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: "compute_loss/add_42" + op: "Add" + input: "compute_loss/Mean_18" + input: "compute_loss/Mean_19" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/Abs_20" + op: "Abs" + input: "compute_loss/sub_29" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Const_32" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_20" + op: "Mean" + input: "compute_loss/Abs_20" + input: "compute_loss/Const_32" + 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: "compute_loss/add_43" + op: "Add" + input: "compute_loss/add_42" + input: "compute_loss/Mean_20" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/Abs_21" + op: "Abs" + input: "compute_loss/sub_28" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 14 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Const_33" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_21" + op: "Mean" + input: "compute_loss/Abs_21" + input: "compute_loss/Const_33" + 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: "compute_loss/add_44" + op: "Add" + input: "compute_loss/add_43" + input: "compute_loss/Mean_21" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul_33/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0625 + } + } + } +} +node { + name: "compute_loss/mul_33" + op: "Mul" + input: "compute_loss/mul_33/x" + input: "compute_loss/add_44" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/add_45" + op: "Add" + input: "compute_loss/add_31" + input: "compute_loss/mul_33" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/strided_slice_72/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_72/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_72/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_72" + op: "StridedSlice" + input: "compute_loss/ResizeArea_7" + input: "compute_loss/strided_slice_72/stack" + input: "compute_loss/strided_slice_72/stack_1" + input: "compute_loss/strided_slice_72/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/Squeeze_12" + op: "Squeeze" + input: "depth_prediction/truediv_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 3 + } + } + } +} +node { + name: "compute_loss/strided_slice_73/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_73/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_73/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_73" + op: "StridedSlice" + input: "pose_and_explainability_prediction/pose_exp_net/pose/mul" + input: "compute_loss/strided_slice_73/stack" + input: "compute_loss/strided_slice_73/stack_1" + input: "compute_loss/strided_slice_73/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 5 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 5 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "compute_loss/strided_slice_74/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\003\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_74/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_74/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_74" + op: "StridedSlice" + input: "data_loading/stack_19" + input: "compute_loss/strided_slice_74/stack" + input: "compute_loss/strided_slice_74/stack_1" + input: "compute_loss/strided_slice_74/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "compute_loss/Slice_42/begin" + 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\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_42/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_42" + op: "Slice" + input: "compute_loss/strided_slice_73" + input: "compute_loss/Slice_42/begin" + input: "compute_loss/Slice_42/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_60/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: "compute_loss/ExpandDims_60" + op: "ExpandDims" + input: "compute_loss/Slice_42" + input: "compute_loss/ExpandDims_60/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_43/begin" + 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\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_43/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_43" + op: "Slice" + input: "compute_loss/strided_slice_73" + input: "compute_loss/Slice_43/begin" + input: "compute_loss/Slice_43/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_44/begin" + 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\004\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_44/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_44" + op: "Slice" + input: "compute_loss/strided_slice_73" + input: "compute_loss/Slice_44/begin" + input: "compute_loss/Slice_44/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_45/begin" + 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\005\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_45/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_45" + op: "Slice" + input: "compute_loss/strided_slice_73" + input: "compute_loss/Slice_45/begin" + input: "compute_loss/Slice_45/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Shape_6" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_75/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: "compute_loss/strided_slice_75/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: "compute_loss/strided_slice_75/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: "compute_loss/strided_slice_75" + op: "StridedSlice" + input: "compute_loss/Shape_6" + input: "compute_loss/strided_slice_75/stack" + input: "compute_loss/strided_slice_75/stack_1" + input: "compute_loss/strided_slice_75/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: "compute_loss/clip_by_value_18/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_18/Minimum" + op: "Minimum" + input: "compute_loss/Slice_45" + input: "compute_loss/clip_by_value_18/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_18/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: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_18" + op: "Maximum" + input: "compute_loss/clip_by_value_18/Minimum" + input: "compute_loss/clip_by_value_18/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_19/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_19/Minimum" + op: "Minimum" + input: "compute_loss/Slice_44" + input: "compute_loss/clip_by_value_19/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_19/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: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_19" + op: "Maximum" + input: "compute_loss/clip_by_value_19/Minimum" + input: "compute_loss/clip_by_value_19/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_20/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_20/Minimum" + op: "Minimum" + input: "compute_loss/Slice_43" + input: "compute_loss/clip_by_value_20/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_20/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: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_20" + op: "Maximum" + input: "compute_loss/clip_by_value_20/Minimum" + input: "compute_loss/clip_by_value_20/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_61/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: "compute_loss/ExpandDims_61" + op: "ExpandDims" + input: "compute_loss/clip_by_value_18" + input: "compute_loss/ExpandDims_61/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_62/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: "compute_loss/ExpandDims_62" + op: "ExpandDims" + input: "compute_loss/ExpandDims_61" + input: "compute_loss/ExpandDims_62/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_63/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: "compute_loss/ExpandDims_63" + op: "ExpandDims" + input: "compute_loss/clip_by_value_19" + input: "compute_loss/ExpandDims_63/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_64/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: "compute_loss/ExpandDims_64" + op: "ExpandDims" + input: "compute_loss/ExpandDims_63" + input: "compute_loss/ExpandDims_64/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_65/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: "compute_loss/ExpandDims_65" + op: "ExpandDims" + input: "compute_loss/clip_by_value_20" + input: "compute_loss/ExpandDims_65/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_66/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: "compute_loss/ExpandDims_66" + op: "ExpandDims" + input: "compute_loss/ExpandDims_65" + input: "compute_loss/ExpandDims_66/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/zeros_12/mul/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: "compute_loss/zeros_12/mul" + op: "Mul" + input: "compute_loss/strided_slice_75" + input: "compute_loss/zeros_12/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_12/mul_1/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: "compute_loss/zeros_12/mul_1" + op: "Mul" + input: "compute_loss/zeros_12/mul" + input: "compute_loss/zeros_12/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_12/mul_2/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: "compute_loss/zeros_12/mul_2" + op: "Mul" + input: "compute_loss/zeros_12/mul_1" + input: "compute_loss/zeros_12/mul_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_12/Less/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: 1000 + } + } + } +} +node { + name: "compute_loss/zeros_12/Less" + op: "Less" + input: "compute_loss/zeros_12/mul_2" + input: "compute_loss/zeros_12/Less/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_12/packed/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: "compute_loss/zeros_12/packed/2" + 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: "compute_loss/zeros_12/packed/3" + 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: "compute_loss/zeros_12/packed" + op: "Pack" + input: "compute_loss/strided_slice_75" + input: "compute_loss/zeros_12/packed/1" + input: "compute_loss/zeros_12/packed/2" + input: "compute_loss/zeros_12/packed/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/zeros_12/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: 0.0 + } + } + } +} +node { + name: "compute_loss/zeros_12" + op: "Fill" + input: "compute_loss/zeros_12/packed" + input: "compute_loss/zeros_12/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/ones_24/mul/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: "compute_loss/ones_24/mul" + op: "Mul" + input: "compute_loss/strided_slice_75" + input: "compute_loss/ones_24/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_24/mul_1/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: "compute_loss/ones_24/mul_1" + op: "Mul" + input: "compute_loss/ones_24/mul" + input: "compute_loss/ones_24/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_24/mul_2/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: "compute_loss/ones_24/mul_2" + op: "Mul" + input: "compute_loss/ones_24/mul_1" + input: "compute_loss/ones_24/mul_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_24/Less/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: 1000 + } + } + } +} +node { + name: "compute_loss/ones_24/Less" + op: "Less" + input: "compute_loss/ones_24/mul_2" + input: "compute_loss/ones_24/Less/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_24/packed/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: "compute_loss/ones_24/packed/2" + 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: "compute_loss/ones_24/packed/3" + 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: "compute_loss/ones_24/packed" + op: "Pack" + input: "compute_loss/strided_slice_75" + input: "compute_loss/ones_24/packed/1" + input: "compute_loss/ones_24/packed/2" + input: "compute_loss/ones_24/packed/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/ones_24/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: "compute_loss/ones_24" + op: "Fill" + input: "compute_loss/ones_24/packed" + input: "compute_loss/ones_24/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/Cos_18" + op: "Cos" + input: "compute_loss/ExpandDims_62" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_18" + op: "Sin" + input: "compute_loss/ExpandDims_62" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_18" + op: "Neg" + input: "compute_loss/Sin_18" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_114/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_114" + op: "ConcatV2" + input: "compute_loss/Cos_18" + input: "compute_loss/Neg_18" + input: "compute_loss/zeros_12" + input: "compute_loss/concat_114/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_115/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_115" + op: "ConcatV2" + input: "compute_loss/Sin_18" + input: "compute_loss/Cos_18" + input: "compute_loss/zeros_12" + input: "compute_loss/concat_115/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_116/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_116" + op: "ConcatV2" + input: "compute_loss/zeros_12" + input: "compute_loss/zeros_12" + input: "compute_loss/ones_24" + input: "compute_loss/concat_116/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_117/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_117" + op: "ConcatV2" + input: "compute_loss/concat_114" + input: "compute_loss/concat_115" + input: "compute_loss/concat_116" + input: "compute_loss/concat_117/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Cos_19" + op: "Cos" + input: "compute_loss/ExpandDims_64" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_19" + op: "Sin" + input: "compute_loss/ExpandDims_64" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_118/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_118" + op: "ConcatV2" + input: "compute_loss/Cos_19" + input: "compute_loss/zeros_12" + input: "compute_loss/Sin_19" + input: "compute_loss/concat_118/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_119/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_119" + op: "ConcatV2" + input: "compute_loss/zeros_12" + input: "compute_loss/ones_24" + input: "compute_loss/zeros_12" + input: "compute_loss/concat_119/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_19" + op: "Neg" + input: "compute_loss/Sin_19" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_120/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_120" + op: "ConcatV2" + input: "compute_loss/Neg_19" + input: "compute_loss/zeros_12" + input: "compute_loss/Cos_19" + input: "compute_loss/concat_120/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_121/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_121" + op: "ConcatV2" + input: "compute_loss/concat_118" + input: "compute_loss/concat_119" + input: "compute_loss/concat_120" + input: "compute_loss/concat_121/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Cos_20" + op: "Cos" + input: "compute_loss/ExpandDims_66" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_20" + op: "Sin" + input: "compute_loss/ExpandDims_66" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_122/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_122" + op: "ConcatV2" + input: "compute_loss/ones_24" + input: "compute_loss/zeros_12" + input: "compute_loss/zeros_12" + input: "compute_loss/concat_122/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_20" + op: "Neg" + input: "compute_loss/Sin_20" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_123/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_123" + op: "ConcatV2" + input: "compute_loss/zeros_12" + input: "compute_loss/Cos_20" + input: "compute_loss/Neg_20" + input: "compute_loss/concat_123/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_124/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_124" + op: "ConcatV2" + input: "compute_loss/zeros_12" + input: "compute_loss/Sin_20" + input: "compute_loss/Cos_20" + input: "compute_loss/concat_124/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_125/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_125" + op: "ConcatV2" + input: "compute_loss/concat_122" + input: "compute_loss/concat_123" + input: "compute_loss/concat_124" + input: "compute_loss/concat_125/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_42" + op: "BatchMatMul" + input: "compute_loss/concat_125" + input: "compute_loss/concat_121" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/MatMul_43" + op: "BatchMatMul" + input: "compute_loss/MatMul_42" + input: "compute_loss/concat_117" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Squeeze_13" + op: "Squeeze" + input: "compute_loss/MatMul_43" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 1 + } + } + } +} +node { + name: "compute_loss/Const_34" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "compute_loss/Tile_18/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_18" + op: "Tile" + input: "compute_loss/Const_34" + input: "compute_loss/Tile_18/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_126/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_126" + op: "ConcatV2" + input: "compute_loss/Squeeze_13" + input: "compute_loss/ExpandDims_60" + input: "compute_loss/concat_126/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_127/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_127" + op: "ConcatV2" + input: "compute_loss/concat_126" + input: "compute_loss/Tile_18" + input: "compute_loss/concat_127/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/stack_18" + 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: "\020\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_25/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: "compute_loss/ones_25" + op: "Fill" + input: "compute_loss/stack_18" + input: "compute_loss/ones_25/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/LinSpace_12/start" + 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: "compute_loss/LinSpace_12/stop" + 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: "compute_loss/LinSpace_12/num" + 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: 52 + } + } + } +} +node { + name: "compute_loss/LinSpace_12" + op: "LinSpace" + input: "compute_loss/LinSpace_12/start" + input: "compute_loss/LinSpace_12/stop" + input: "compute_loss/LinSpace_12/num" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_67/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: "compute_loss/ExpandDims_67" + op: "ExpandDims" + input: "compute_loss/LinSpace_12" + input: "compute_loss/ExpandDims_67/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/transpose_12/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/transpose_12" + op: "Transpose" + input: "compute_loss/ExpandDims_67" + input: "compute_loss/transpose_12/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_44" + op: "MatMul" + input: "compute_loss/ones_25" + input: "compute_loss/transpose_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/LinSpace_13/start" + 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: "compute_loss/LinSpace_13/stop" + 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: "compute_loss/LinSpace_13/num" + 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: 16 + } + } + } +} +node { + name: "compute_loss/LinSpace_13" + op: "LinSpace" + input: "compute_loss/LinSpace_13/start" + input: "compute_loss/LinSpace_13/stop" + input: "compute_loss/LinSpace_13/num" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_68/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: "compute_loss/ExpandDims_68" + op: "ExpandDims" + input: "compute_loss/LinSpace_13" + input: "compute_loss/ExpandDims_68/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/stack_19" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\0004\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_26/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: "compute_loss/ones_26" + op: "Fill" + input: "compute_loss/stack_19" + input: "compute_loss/ones_26/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 52 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/MatMul_45" + op: "MatMul" + input: "compute_loss/ExpandDims_68" + input: "compute_loss/ones_26" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/add_46/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: 1.0 + } + } + } +} +node { + name: "compute_loss/add_46" + op: "Add" + input: "compute_loss/MatMul_44" + input: "compute_loss/add_46/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/mul_34/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } +} +node { + name: "compute_loss/mul_34" + op: "Mul" + input: "compute_loss/add_46" + input: "compute_loss/mul_34/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/Cast_12/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 51 + } + } + } +} +node { + name: "compute_loss/Cast_12" + op: "Cast" + input: "compute_loss/Cast_12/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul_35" + op: "Mul" + input: "compute_loss/mul_34" + input: "compute_loss/Cast_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/add_47/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: 1.0 + } + } + } +} +node { + name: "compute_loss/add_47" + op: "Add" + input: "compute_loss/MatMul_45" + input: "compute_loss/add_47/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/mul_36/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } +} +node { + name: "compute_loss/mul_36" + op: "Mul" + input: "compute_loss/add_47" + input: "compute_loss/mul_36/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/Cast_13/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 15 + } + } + } +} +node { + name: "compute_loss/Cast_13" + op: "Cast" + input: "compute_loss/Cast_13/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul_37" + op: "Mul" + input: "compute_loss/mul_36" + input: "compute_loss/Cast_13" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/ones_like_6/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\020\000\000\0004\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_like_6/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: "compute_loss/ones_like_6" + op: "Fill" + input: "compute_loss/ones_like_6/Shape" + input: "compute_loss/ones_like_6/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/stack_20" + op: "Pack" + input: "compute_loss/mul_35" + input: "compute_loss/mul_37" + input: "compute_loss/ones_like_6" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/ExpandDims_69/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: "compute_loss/ExpandDims_69" + op: "ExpandDims" + input: "compute_loss/stack_20" + input: "compute_loss/ExpandDims_69/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: 3 + } + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/Tile_19/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_19" + op: "Tile" + input: "compute_loss/ExpandDims_69" + input: "compute_loss/Tile_19/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_30/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_30" + op: "Reshape" + input: "compute_loss/Squeeze_12" + input: "compute_loss/Reshape_30/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_31/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_31" + op: "Reshape" + input: "compute_loss/Tile_19" + input: "compute_loss/Reshape_31/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/MatrixInverse_6" + op: "MatrixInverse" + input: "compute_loss/strided_slice_74" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adjoint" + value { + b: false + } + } +} +node { + name: "compute_loss/MatMul_46" + op: "BatchMatMul" + input: "compute_loss/MatrixInverse_6" + input: "compute_loss/Reshape_31" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 832 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/mul_38" + op: "Mul" + input: "compute_loss/MatMul_46" + input: "compute_loss/Reshape_30" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/ones_27/shape_as_tensor" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "compute_loss/ones_27/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: "compute_loss/ones_27" + op: "Fill" + input: "compute_loss/ones_27/shape_as_tensor" + input: "compute_loss/ones_27/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/concat_128/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_128" + op: "ConcatV2" + input: "compute_loss/mul_38" + input: "compute_loss/ones_27" + input: "compute_loss/concat_128/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_32/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\377\377\377\377\020\000\000\0004\000\000\000" + } + } + } +} +node { + name: "compute_loss/Reshape_32" + op: "Reshape" + input: "compute_loss/concat_128" + input: "compute_loss/Reshape_32/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/Const_35" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "compute_loss/Tile_20/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_20" + op: "Tile" + input: "compute_loss/Const_35" + input: "compute_loss/Tile_20/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/zeros_13" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "compute_loss/concat_129/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_129" + op: "ConcatV2" + input: "compute_loss/strided_slice_74" + input: "compute_loss/zeros_13" + input: "compute_loss/concat_129/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_130/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_130" + op: "ConcatV2" + input: "compute_loss/concat_129" + input: "compute_loss/Tile_20" + input: "compute_loss/concat_130/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_47" + op: "BatchMatMul" + input: "compute_loss/concat_130" + input: "compute_loss/concat_127" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Reshape_33/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_33" + op: "Reshape" + input: "compute_loss/Reshape_32" + input: "compute_loss/Reshape_33/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_48" + op: "BatchMatMul" + input: "compute_loss/MatMul_47" + input: "compute_loss/Reshape_33" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Slice_46/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_46/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_46" + op: "Slice" + input: "compute_loss/MatMul_48" + input: "compute_loss/Slice_46/begin" + input: "compute_loss/Slice_46/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_47/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_47/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_47" + op: "Slice" + input: "compute_loss/MatMul_48" + input: "compute_loss/Slice_47/begin" + input: "compute_loss/Slice_47/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_48/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_48/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_48" + op: "Slice" + input: "compute_loss/MatMul_48" + input: "compute_loss/Slice_48/begin" + input: "compute_loss/Slice_48/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/add_48/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: 1.000000013351432e-10 + } + } + } +} +node { + name: "compute_loss/add_48" + op: "Add" + input: "compute_loss/Slice_48" + input: "compute_loss/add_48/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/truediv_12" + op: "RealDiv" + input: "compute_loss/Slice_46" + input: "compute_loss/add_48" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/add_49/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: 1.000000013351432e-10 + } + } + } +} +node { + name: "compute_loss/add_49" + op: "Add" + input: "compute_loss/Slice_48" + input: "compute_loss/add_49/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/truediv_13" + op: "RealDiv" + input: "compute_loss/Slice_47" + input: "compute_loss/add_49" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/concat_131/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_131" + op: "ConcatV2" + input: "compute_loss/truediv_12" + input: "compute_loss/truediv_13" + input: "compute_loss/concat_131/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_34/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\020\000\000\0004\000\000\000" + } + } + } +} +node { + name: "compute_loss/Reshape_34" + op: "Reshape" + input: "compute_loss/concat_131" + input: "compute_loss/Reshape_34/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/transpose_13/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/transpose_13" + op: "Transpose" + input: "compute_loss/Reshape_34" + input: "compute_loss/transpose_13/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/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: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_6/split/split_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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_6/split" + op: "SplitV" + input: "compute_loss/transpose_13" + input: "compute_loss/image_sampling_6/Const" + input: "compute_loss/image_sampling_6/split/split_dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tlen" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "num_split" + value { + i: 2 + } + } +} +node { + name: "compute_loss/image_sampling_6/Floor" + op: "Floor" + input: "compute_loss/image_sampling_6/split" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/add/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_6/add" + op: "Add" + input: "compute_loss/image_sampling_6/Floor" + input: "compute_loss/image_sampling_6/add/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Floor_1" + op: "Floor" + input: "compute_loss/image_sampling_6/split:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/add_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: 1.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_6/add_1" + op: "Add" + input: "compute_loss/image_sampling_6/Floor_1" + input: "compute_loss/image_sampling_6/add_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_6/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: 1 + } + } + } +} +node { + name: "compute_loss/image_sampling_6/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: 2 + } + } + } +} +node { + name: "compute_loss/image_sampling_6/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: "compute_loss/image_sampling_6/strided_slice" + op: "StridedSlice" + input: "compute_loss/image_sampling_6/Shape" + input: "compute_loss/image_sampling_6/strided_slice/stack" + input: "compute_loss/image_sampling_6/strided_slice/stack_1" + input: "compute_loss/image_sampling_6/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: "compute_loss/image_sampling_6/sub/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/image_sampling_6/sub" + op: "Sub" + input: "compute_loss/image_sampling_6/strided_slice" + input: "compute_loss/image_sampling_6/sub/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Cast_2" + op: "Cast" + input: "compute_loss/image_sampling_6/sub" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_6/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: 2 + } + } + } +} +node { + name: "compute_loss/image_sampling_6/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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_6/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: "compute_loss/image_sampling_6/strided_slice_1" + op: "StridedSlice" + input: "compute_loss/image_sampling_6/Shape_1" + input: "compute_loss/image_sampling_6/strided_slice_1/stack" + input: "compute_loss/image_sampling_6/strided_slice_1/stack_1" + input: "compute_loss/image_sampling_6/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: "compute_loss/image_sampling_6/sub_1/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: "compute_loss/image_sampling_6/sub_1" + op: "Sub" + input: "compute_loss/image_sampling_6/strided_slice_1" + input: "compute_loss/image_sampling_6/sub_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Cast_3" + op: "Cast" + input: "compute_loss/image_sampling_6/sub_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/zeros" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_6/clip_by_value/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_6/Floor" + input: "compute_loss/image_sampling_6/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/clip_by_value" + op: "Maximum" + input: "compute_loss/image_sampling_6/clip_by_value/Minimum" + input: "compute_loss/image_sampling_6/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/clip_by_value_1/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_6/Floor_1" + input: "compute_loss/image_sampling_6/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/clip_by_value_1" + op: "Maximum" + input: "compute_loss/image_sampling_6/clip_by_value_1/Minimum" + input: "compute_loss/image_sampling_6/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/clip_by_value_2/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_6/add" + input: "compute_loss/image_sampling_6/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/clip_by_value_2" + op: "Maximum" + input: "compute_loss/image_sampling_6/clip_by_value_2/Minimum" + input: "compute_loss/image_sampling_6/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/clip_by_value_3/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_6/add_1" + input: "compute_loss/image_sampling_6/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/clip_by_value_3" + op: "Maximum" + input: "compute_loss/image_sampling_6/clip_by_value_3/Minimum" + input: "compute_loss/image_sampling_6/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/sub_2" + op: "Sub" + input: "compute_loss/image_sampling_6/clip_by_value_2" + input: "compute_loss/image_sampling_6/split" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/sub_3" + op: "Sub" + input: "compute_loss/image_sampling_6/split" + input: "compute_loss/image_sampling_6/clip_by_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/sub_4" + op: "Sub" + input: "compute_loss/image_sampling_6/clip_by_value_3" + input: "compute_loss/image_sampling_6/split:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/sub_5" + op: "Sub" + input: "compute_loss/image_sampling_6/split:1" + input: "compute_loss/image_sampling_6/clip_by_value_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Cast_4/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 52 + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Cast_4" + op: "Cast" + input: "compute_loss/image_sampling_6/Cast_4/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Cast_5/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 832 + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Cast_5" + op: "Cast" + input: "compute_loss/image_sampling_6/Cast_5/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/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: "compute_loss/image_sampling_6/range/limit" + 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: 4 + } + } + } +} +node { + name: "compute_loss/image_sampling_6/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: "compute_loss/image_sampling_6/range" + op: "Range" + input: "compute_loss/image_sampling_6/range/start" + input: "compute_loss/image_sampling_6/range/limit" + input: "compute_loss/image_sampling_6/range/delta" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Cast_6" + op: "Cast" + input: "compute_loss/image_sampling_6/range" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/mul" + op: "Mul" + input: "compute_loss/image_sampling_6/Cast_6" + input: "compute_loss/image_sampling_6/Cast_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/stack" + 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: 832 + } + } + } +} +node { + name: "compute_loss/image_sampling_6/stack_1/values_0" + 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: 832 + } + } + } +} +node { + name: "compute_loss/image_sampling_6/stack_1" + op: "Pack" + input: "compute_loss/image_sampling_6/stack_1/values_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: "compute_loss/image_sampling_6/ones/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: "compute_loss/image_sampling_6/ones" + op: "Fill" + input: "compute_loss/image_sampling_6/stack_1" + input: "compute_loss/image_sampling_6/ones/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 832 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/image_sampling_6/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: "compute_loss/image_sampling_6/ExpandDims" + op: "ExpandDims" + input: "compute_loss/image_sampling_6/ones" + input: "compute_loss/image_sampling_6/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: 832 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/transpose/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_6/transpose" + op: "Transpose" + input: "compute_loss/image_sampling_6/ExpandDims" + input: "compute_loss/image_sampling_6/transpose/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Reshape" + op: "Reshape" + input: "compute_loss/image_sampling_6/mul" + input: "compute_loss/image_sampling_6/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: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/MatMul" + op: "MatMul" + input: "compute_loss/image_sampling_6/Reshape" + input: "compute_loss/image_sampling_6/transpose" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/image_sampling_6/Reshape_1/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -1 + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Reshape_1" + op: "Reshape" + input: "compute_loss/image_sampling_6/MatMul" + input: "compute_loss/image_sampling_6/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Reshape_2/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Reshape_2" + op: "Reshape" + input: "compute_loss/image_sampling_6/Reshape_1" + input: "compute_loss/image_sampling_6/Reshape_2/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/mul_1" + op: "Mul" + input: "compute_loss/image_sampling_6/clip_by_value_1" + input: "compute_loss/image_sampling_6/Cast_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/add_2" + op: "Add" + input: "compute_loss/image_sampling_6/Reshape_2" + input: "compute_loss/image_sampling_6/mul_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/mul_2" + op: "Mul" + input: "compute_loss/image_sampling_6/clip_by_value_3" + input: "compute_loss/image_sampling_6/Cast_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/add_3" + op: "Add" + input: "compute_loss/image_sampling_6/Reshape_2" + input: "compute_loss/image_sampling_6/mul_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/add_4" + op: "Add" + input: "compute_loss/image_sampling_6/clip_by_value" + input: "compute_loss/image_sampling_6/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Reshape_3/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: "compute_loss/image_sampling_6/Reshape_3" + op: "Reshape" + input: "compute_loss/image_sampling_6/add_4" + input: "compute_loss/image_sampling_6/Reshape_3/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/add_5" + op: "Add" + input: "compute_loss/image_sampling_6/clip_by_value" + input: "compute_loss/image_sampling_6/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/add_6" + op: "Add" + input: "compute_loss/image_sampling_6/clip_by_value_2" + input: "compute_loss/image_sampling_6/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/add_7" + op: "Add" + input: "compute_loss/image_sampling_6/clip_by_value_2" + input: "compute_loss/image_sampling_6/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/stack_2" + 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: "compute_loss/image_sampling_6/stack_3/values_0" + 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: "compute_loss/image_sampling_6/stack_3/values_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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_6/stack_3" + op: "Pack" + input: "compute_loss/image_sampling_6/stack_3/values_0" + input: "compute_loss/image_sampling_6/stack_3/values_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: "compute_loss/image_sampling_6/Reshape_4" + op: "Reshape" + input: "compute_loss/strided_slice_72" + input: "compute_loss/image_sampling_6/stack_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3328 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Cast_9" + op: "Cast" + input: "compute_loss/image_sampling_6/Reshape_3" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/GatherV2/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: "compute_loss/image_sampling_6/GatherV2" + op: "GatherV2" + input: "compute_loss/image_sampling_6/Reshape_4" + input: "compute_loss/image_sampling_6/Cast_9" + input: "compute_loss/image_sampling_6/GatherV2/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3328 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Reshape_5/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Reshape_5" + op: "Reshape" + input: "compute_loss/image_sampling_6/GatherV2" + input: "compute_loss/image_sampling_6/Reshape_5/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Cast_10" + op: "Cast" + input: "compute_loss/image_sampling_6/add_5" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/GatherV2_1/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: "compute_loss/image_sampling_6/GatherV2_1" + op: "GatherV2" + input: "compute_loss/image_sampling_6/Reshape_4" + input: "compute_loss/image_sampling_6/Cast_10" + input: "compute_loss/image_sampling_6/GatherV2_1/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Reshape_6/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Reshape_6" + op: "Reshape" + input: "compute_loss/image_sampling_6/GatherV2_1" + input: "compute_loss/image_sampling_6/Reshape_6/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Cast_11" + op: "Cast" + input: "compute_loss/image_sampling_6/add_6" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/GatherV2_2/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: "compute_loss/image_sampling_6/GatherV2_2" + op: "GatherV2" + input: "compute_loss/image_sampling_6/Reshape_4" + input: "compute_loss/image_sampling_6/Cast_11" + input: "compute_loss/image_sampling_6/GatherV2_2/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Reshape_7/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Reshape_7" + op: "Reshape" + input: "compute_loss/image_sampling_6/GatherV2_2" + input: "compute_loss/image_sampling_6/Reshape_7/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Cast_12" + op: "Cast" + input: "compute_loss/image_sampling_6/add_7" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/GatherV2_3/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: "compute_loss/image_sampling_6/GatherV2_3" + op: "GatherV2" + input: "compute_loss/image_sampling_6/Reshape_4" + input: "compute_loss/image_sampling_6/Cast_12" + input: "compute_loss/image_sampling_6/GatherV2_3/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Reshape_8/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_6/Reshape_8" + op: "Reshape" + input: "compute_loss/image_sampling_6/GatherV2_3" + input: "compute_loss/image_sampling_6/Reshape_8/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/mul_3" + op: "Mul" + input: "compute_loss/image_sampling_6/sub_2" + input: "compute_loss/image_sampling_6/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/mul_4" + op: "Mul" + input: "compute_loss/image_sampling_6/sub_2" + input: "compute_loss/image_sampling_6/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/mul_5" + op: "Mul" + input: "compute_loss/image_sampling_6/sub_3" + input: "compute_loss/image_sampling_6/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/mul_6" + op: "Mul" + input: "compute_loss/image_sampling_6/sub_3" + input: "compute_loss/image_sampling_6/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/mul_7" + op: "Mul" + input: "compute_loss/image_sampling_6/mul_3" + input: "compute_loss/image_sampling_6/Reshape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/mul_8" + op: "Mul" + input: "compute_loss/image_sampling_6/mul_4" + input: "compute_loss/image_sampling_6/Reshape_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/mul_9" + op: "Mul" + input: "compute_loss/image_sampling_6/mul_5" + input: "compute_loss/image_sampling_6/Reshape_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/mul_10" + op: "Mul" + input: "compute_loss/image_sampling_6/mul_6" + input: "compute_loss/image_sampling_6/Reshape_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_6/AddN" + op: "AddN" + input: "compute_loss/image_sampling_6/mul_7" + input: "compute_loss/image_sampling_6/mul_8" + input: "compute_loss/image_sampling_6/mul_9" + input: "compute_loss/image_sampling_6/mul_10" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/sub_30" + op: "Sub" + input: "compute_loss/image_sampling_6/AddN" + input: "compute_loss/ResizeArea_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Abs_22" + op: "Abs" + input: "compute_loss/sub_30" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Const_36" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_22" + op: "Mean" + input: "compute_loss/Abs_22" + input: "compute_loss/Const_36" + 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: "compute_loss/add_50" + op: "Add" + input: "compute_loss/add_41" + input: "compute_loss/Mean_22" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/strided_slice_76/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_76/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_76/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_76" + op: "StridedSlice" + input: "compute_loss/ResizeArea_7" + input: "compute_loss/strided_slice_76/stack" + input: "compute_loss/strided_slice_76/stack_1" + input: "compute_loss/strided_slice_76/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "compute_loss/Squeeze_14" + op: "Squeeze" + input: "depth_prediction/truediv_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 3 + } + } + } +} +node { + name: "compute_loss/strided_slice_77/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_77/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_77/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_77" + op: "StridedSlice" + input: "pose_and_explainability_prediction/pose_exp_net/pose/mul" + input: "compute_loss/strided_slice_77/stack" + input: "compute_loss/strided_slice_77/stack_1" + input: "compute_loss/strided_slice_77/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 5 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 5 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "compute_loss/strided_slice_78/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\003\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_78/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_78/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_78" + op: "StridedSlice" + input: "data_loading/stack_19" + input: "compute_loss/strided_slice_78/stack" + input: "compute_loss/strided_slice_78/stack_1" + input: "compute_loss/strided_slice_78/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "compute_loss/Slice_49/begin" + 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\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_49/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_49" + op: "Slice" + input: "compute_loss/strided_slice_77" + input: "compute_loss/Slice_49/begin" + input: "compute_loss/Slice_49/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_70/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: "compute_loss/ExpandDims_70" + op: "ExpandDims" + input: "compute_loss/Slice_49" + input: "compute_loss/ExpandDims_70/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_50/begin" + 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\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_50/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_50" + op: "Slice" + input: "compute_loss/strided_slice_77" + input: "compute_loss/Slice_50/begin" + input: "compute_loss/Slice_50/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_51/begin" + 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\004\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_51/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_51" + op: "Slice" + input: "compute_loss/strided_slice_77" + input: "compute_loss/Slice_51/begin" + input: "compute_loss/Slice_51/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_52/begin" + 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\005\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_52/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_52" + op: "Slice" + input: "compute_loss/strided_slice_77" + input: "compute_loss/Slice_52/begin" + input: "compute_loss/Slice_52/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Shape_7" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/strided_slice_79/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: "compute_loss/strided_slice_79/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: "compute_loss/strided_slice_79/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: "compute_loss/strided_slice_79" + op: "StridedSlice" + input: "compute_loss/Shape_7" + input: "compute_loss/strided_slice_79/stack" + input: "compute_loss/strided_slice_79/stack_1" + input: "compute_loss/strided_slice_79/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: "compute_loss/clip_by_value_21/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_21/Minimum" + op: "Minimum" + input: "compute_loss/Slice_52" + input: "compute_loss/clip_by_value_21/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_21/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: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_21" + op: "Maximum" + input: "compute_loss/clip_by_value_21/Minimum" + input: "compute_loss/clip_by_value_21/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_22/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_22/Minimum" + op: "Minimum" + input: "compute_loss/Slice_51" + input: "compute_loss/clip_by_value_22/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_22/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: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_22" + op: "Maximum" + input: "compute_loss/clip_by_value_22/Minimum" + input: "compute_loss/clip_by_value_22/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_23/Minimum/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: 3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_23/Minimum" + op: "Minimum" + input: "compute_loss/Slice_50" + input: "compute_loss/clip_by_value_23/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/clip_by_value_23/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: -3.1415927410125732 + } + } + } +} +node { + name: "compute_loss/clip_by_value_23" + op: "Maximum" + input: "compute_loss/clip_by_value_23/Minimum" + input: "compute_loss/clip_by_value_23/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_71/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: "compute_loss/ExpandDims_71" + op: "ExpandDims" + input: "compute_loss/clip_by_value_21" + input: "compute_loss/ExpandDims_71/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_72/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: "compute_loss/ExpandDims_72" + op: "ExpandDims" + input: "compute_loss/ExpandDims_71" + input: "compute_loss/ExpandDims_72/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_73/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: "compute_loss/ExpandDims_73" + op: "ExpandDims" + input: "compute_loss/clip_by_value_22" + input: "compute_loss/ExpandDims_73/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_74/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: "compute_loss/ExpandDims_74" + op: "ExpandDims" + input: "compute_loss/ExpandDims_73" + input: "compute_loss/ExpandDims_74/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_75/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: "compute_loss/ExpandDims_75" + op: "ExpandDims" + input: "compute_loss/clip_by_value_23" + input: "compute_loss/ExpandDims_75/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_76/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: "compute_loss/ExpandDims_76" + op: "ExpandDims" + input: "compute_loss/ExpandDims_75" + input: "compute_loss/ExpandDims_76/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/zeros_14/mul/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: "compute_loss/zeros_14/mul" + op: "Mul" + input: "compute_loss/strided_slice_79" + input: "compute_loss/zeros_14/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_14/mul_1/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: "compute_loss/zeros_14/mul_1" + op: "Mul" + input: "compute_loss/zeros_14/mul" + input: "compute_loss/zeros_14/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_14/mul_2/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: "compute_loss/zeros_14/mul_2" + op: "Mul" + input: "compute_loss/zeros_14/mul_1" + input: "compute_loss/zeros_14/mul_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_14/Less/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: 1000 + } + } + } +} +node { + name: "compute_loss/zeros_14/Less" + op: "Less" + input: "compute_loss/zeros_14/mul_2" + input: "compute_loss/zeros_14/Less/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/zeros_14/packed/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: "compute_loss/zeros_14/packed/2" + 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: "compute_loss/zeros_14/packed/3" + 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: "compute_loss/zeros_14/packed" + op: "Pack" + input: "compute_loss/strided_slice_79" + input: "compute_loss/zeros_14/packed/1" + input: "compute_loss/zeros_14/packed/2" + input: "compute_loss/zeros_14/packed/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/zeros_14/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: 0.0 + } + } + } +} +node { + name: "compute_loss/zeros_14" + op: "Fill" + input: "compute_loss/zeros_14/packed" + input: "compute_loss/zeros_14/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/ones_28/mul/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: "compute_loss/ones_28/mul" + op: "Mul" + input: "compute_loss/strided_slice_79" + input: "compute_loss/ones_28/mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_28/mul_1/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: "compute_loss/ones_28/mul_1" + op: "Mul" + input: "compute_loss/ones_28/mul" + input: "compute_loss/ones_28/mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_28/mul_2/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: "compute_loss/ones_28/mul_2" + op: "Mul" + input: "compute_loss/ones_28/mul_1" + input: "compute_loss/ones_28/mul_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_28/Less/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: 1000 + } + } + } +} +node { + name: "compute_loss/ones_28/Less" + op: "Less" + input: "compute_loss/ones_28/mul_2" + input: "compute_loss/ones_28/Less/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/ones_28/packed/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: "compute_loss/ones_28/packed/2" + 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: "compute_loss/ones_28/packed/3" + 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: "compute_loss/ones_28/packed" + op: "Pack" + input: "compute_loss/strided_slice_79" + input: "compute_loss/ones_28/packed/1" + input: "compute_loss/ones_28/packed/2" + input: "compute_loss/ones_28/packed/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/ones_28/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: "compute_loss/ones_28" + op: "Fill" + input: "compute_loss/ones_28/packed" + input: "compute_loss/ones_28/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/Cos_21" + op: "Cos" + input: "compute_loss/ExpandDims_72" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_21" + op: "Sin" + input: "compute_loss/ExpandDims_72" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_21" + op: "Neg" + input: "compute_loss/Sin_21" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_132/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_132" + op: "ConcatV2" + input: "compute_loss/Cos_21" + input: "compute_loss/Neg_21" + input: "compute_loss/zeros_14" + input: "compute_loss/concat_132/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_133/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_133" + op: "ConcatV2" + input: "compute_loss/Sin_21" + input: "compute_loss/Cos_21" + input: "compute_loss/zeros_14" + input: "compute_loss/concat_133/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_134/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_134" + op: "ConcatV2" + input: "compute_loss/zeros_14" + input: "compute_loss/zeros_14" + input: "compute_loss/ones_28" + input: "compute_loss/concat_134/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_135/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_135" + op: "ConcatV2" + input: "compute_loss/concat_132" + input: "compute_loss/concat_133" + input: "compute_loss/concat_134" + input: "compute_loss/concat_135/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Cos_22" + op: "Cos" + input: "compute_loss/ExpandDims_74" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_22" + op: "Sin" + input: "compute_loss/ExpandDims_74" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_136/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_136" + op: "ConcatV2" + input: "compute_loss/Cos_22" + input: "compute_loss/zeros_14" + input: "compute_loss/Sin_22" + input: "compute_loss/concat_136/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_137/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_137" + op: "ConcatV2" + input: "compute_loss/zeros_14" + input: "compute_loss/ones_28" + input: "compute_loss/zeros_14" + input: "compute_loss/concat_137/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_22" + op: "Neg" + input: "compute_loss/Sin_22" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_138/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_138" + op: "ConcatV2" + input: "compute_loss/Neg_22" + input: "compute_loss/zeros_14" + input: "compute_loss/Cos_22" + input: "compute_loss/concat_138/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_139/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_139" + op: "ConcatV2" + input: "compute_loss/concat_136" + input: "compute_loss/concat_137" + input: "compute_loss/concat_138" + input: "compute_loss/concat_139/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Cos_23" + op: "Cos" + input: "compute_loss/ExpandDims_76" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/Sin_23" + op: "Sin" + input: "compute_loss/ExpandDims_76" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_140/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_140" + op: "ConcatV2" + input: "compute_loss/ones_28" + input: "compute_loss/zeros_14" + input: "compute_loss/zeros_14" + input: "compute_loss/concat_140/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Neg_23" + op: "Neg" + input: "compute_loss/Sin_23" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/concat_141/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_141" + op: "ConcatV2" + input: "compute_loss/zeros_14" + input: "compute_loss/Cos_23" + input: "compute_loss/Neg_23" + input: "compute_loss/concat_141/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_142/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_142" + op: "ConcatV2" + input: "compute_loss/zeros_14" + input: "compute_loss/Sin_23" + input: "compute_loss/Cos_23" + input: "compute_loss/concat_142/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/concat_143/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_143" + op: "ConcatV2" + input: "compute_loss/concat_140" + input: "compute_loss/concat_141" + input: "compute_loss/concat_142" + input: "compute_loss/concat_143/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_49" + op: "BatchMatMul" + input: "compute_loss/concat_143" + input: "compute_loss/concat_139" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/MatMul_50" + op: "BatchMatMul" + input: "compute_loss/MatMul_49" + input: "compute_loss/concat_135" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Squeeze_15" + op: "Squeeze" + input: "compute_loss/MatMul_50" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 1 + } + } + } +} +node { + name: "compute_loss/Const_37" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "compute_loss/Tile_21/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_21" + op: "Tile" + input: "compute_loss/Const_37" + input: "compute_loss/Tile_21/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_144/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_144" + op: "ConcatV2" + input: "compute_loss/Squeeze_15" + input: "compute_loss/ExpandDims_70" + input: "compute_loss/concat_144/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_145/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_145" + op: "ConcatV2" + input: "compute_loss/concat_144" + input: "compute_loss/Tile_21" + input: "compute_loss/concat_145/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/stack_21" + 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: "\020\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_29/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: "compute_loss/ones_29" + op: "Fill" + input: "compute_loss/stack_21" + input: "compute_loss/ones_29/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/LinSpace_14/start" + 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: "compute_loss/LinSpace_14/stop" + 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: "compute_loss/LinSpace_14/num" + 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: 52 + } + } + } +} +node { + name: "compute_loss/LinSpace_14" + op: "LinSpace" + input: "compute_loss/LinSpace_14/start" + input: "compute_loss/LinSpace_14/stop" + input: "compute_loss/LinSpace_14/num" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_77/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: "compute_loss/ExpandDims_77" + op: "ExpandDims" + input: "compute_loss/LinSpace_14" + input: "compute_loss/ExpandDims_77/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/transpose_14/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/transpose_14" + op: "Transpose" + input: "compute_loss/ExpandDims_77" + input: "compute_loss/transpose_14/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_51" + op: "MatMul" + input: "compute_loss/ones_29" + input: "compute_loss/transpose_14" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/LinSpace_15/start" + 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: "compute_loss/LinSpace_15/stop" + 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: "compute_loss/LinSpace_15/num" + 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: 16 + } + } + } +} +node { + name: "compute_loss/LinSpace_15" + op: "LinSpace" + input: "compute_loss/LinSpace_15/start" + input: "compute_loss/LinSpace_15/stop" + input: "compute_loss/LinSpace_15/num" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } +} +node { + name: "compute_loss/ExpandDims_78/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: "compute_loss/ExpandDims_78" + op: "ExpandDims" + input: "compute_loss/LinSpace_15" + input: "compute_loss/ExpandDims_78/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/stack_22" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\0004\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_30/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: "compute_loss/ones_30" + op: "Fill" + input: "compute_loss/stack_22" + input: "compute_loss/ones_30/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 52 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/MatMul_52" + op: "MatMul" + input: "compute_loss/ExpandDims_78" + input: "compute_loss/ones_30" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/add_51/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: 1.0 + } + } + } +} +node { + name: "compute_loss/add_51" + op: "Add" + input: "compute_loss/MatMul_51" + input: "compute_loss/add_51/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/mul_39/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } +} +node { + name: "compute_loss/mul_39" + op: "Mul" + input: "compute_loss/add_51" + input: "compute_loss/mul_39/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/Cast_14/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 51 + } + } + } +} +node { + name: "compute_loss/Cast_14" + op: "Cast" + input: "compute_loss/Cast_14/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul_40" + op: "Mul" + input: "compute_loss/mul_39" + input: "compute_loss/Cast_14" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/add_52/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: 1.0 + } + } + } +} +node { + name: "compute_loss/add_52" + op: "Add" + input: "compute_loss/MatMul_52" + input: "compute_loss/add_52/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/mul_41/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.5 + } + } + } +} +node { + name: "compute_loss/mul_41" + op: "Mul" + input: "compute_loss/add_52" + input: "compute_loss/mul_41/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/Cast_15/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 15 + } + } + } +} +node { + name: "compute_loss/Cast_15" + op: "Cast" + input: "compute_loss/Cast_15/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/mul_42" + op: "Mul" + input: "compute_loss/mul_41" + input: "compute_loss/Cast_15" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/ones_like_7/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\020\000\000\0004\000\000\000" + } + } + } +} +node { + name: "compute_loss/ones_like_7/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: "compute_loss/ones_like_7" + op: "Fill" + input: "compute_loss/ones_like_7/Shape" + input: "compute_loss/ones_like_7/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/stack_23" + op: "Pack" + input: "compute_loss/mul_40" + input: "compute_loss/mul_42" + input: "compute_loss/ones_like_7" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "compute_loss/ExpandDims_79/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: "compute_loss/ExpandDims_79" + op: "ExpandDims" + input: "compute_loss/stack_23" + input: "compute_loss/ExpandDims_79/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: 3 + } + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/Tile_22/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_22" + op: "Tile" + input: "compute_loss/ExpandDims_79" + input: "compute_loss/Tile_22/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_35/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_35" + op: "Reshape" + input: "compute_loss/Squeeze_14" + input: "compute_loss/Reshape_35/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_36/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_36" + op: "Reshape" + input: "compute_loss/Tile_22" + input: "compute_loss/Reshape_36/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/MatrixInverse_7" + op: "MatrixInverse" + input: "compute_loss/strided_slice_78" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adjoint" + value { + b: false + } + } +} +node { + name: "compute_loss/MatMul_53" + op: "BatchMatMul" + input: "compute_loss/MatrixInverse_7" + input: "compute_loss/Reshape_36" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 832 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/mul_43" + op: "Mul" + input: "compute_loss/MatMul_53" + input: "compute_loss/Reshape_35" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/ones_31/shape_as_tensor" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "compute_loss/ones_31/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: "compute_loss/ones_31" + op: "Fill" + input: "compute_loss/ones_31/shape_as_tensor" + input: "compute_loss/ones_31/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/concat_146/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_146" + op: "ConcatV2" + input: "compute_loss/mul_43" + input: "compute_loss/ones_31" + input: "compute_loss/concat_146/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_37/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\377\377\377\377\020\000\000\0004\000\000\000" + } + } + } +} +node { + name: "compute_loss/Reshape_37" + op: "Reshape" + input: "compute_loss/concat_146" + input: "compute_loss/Reshape_37/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/Const_38" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200?" + } + } + } +} +node { + name: "compute_loss/Tile_23/multiples" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/Tile_23" + op: "Tile" + input: "compute_loss/Const_38" + input: "compute_loss/Tile_23/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/zeros_15" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "compute_loss/concat_147/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: 2 + } + } + } +} +node { + name: "compute_loss/concat_147" + op: "ConcatV2" + input: "compute_loss/strided_slice_78" + input: "compute_loss/zeros_15" + input: "compute_loss/concat_147/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/concat_148/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_148" + op: "ConcatV2" + input: "compute_loss/concat_147" + input: "compute_loss/Tile_23" + input: "compute_loss/concat_148/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_54" + op: "BatchMatMul" + input: "compute_loss/concat_148" + input: "compute_loss/concat_145" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Reshape_38/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Reshape_38" + op: "Reshape" + input: "compute_loss/Reshape_37" + input: "compute_loss/Reshape_38/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/MatMul_55" + op: "BatchMatMul" + input: "compute_loss/MatMul_54" + input: "compute_loss/Reshape_38" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "compute_loss/Slice_53/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_53/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_53" + op: "Slice" + input: "compute_loss/MatMul_55" + input: "compute_loss/Slice_53/begin" + input: "compute_loss/Slice_53/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_54/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_54/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_54" + op: "Slice" + input: "compute_loss/MatMul_55" + input: "compute_loss/Slice_54/begin" + input: "compute_loss/Slice_54/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/Slice_55/begin" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/Slice_55/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\001\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "compute_loss/Slice_55" + op: "Slice" + input: "compute_loss/MatMul_55" + input: "compute_loss/Slice_55/begin" + input: "compute_loss/Slice_55/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/add_53/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: 1.000000013351432e-10 + } + } + } +} +node { + name: "compute_loss/add_53" + op: "Add" + input: "compute_loss/Slice_55" + input: "compute_loss/add_53/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/truediv_14" + op: "RealDiv" + input: "compute_loss/Slice_53" + input: "compute_loss/add_53" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/add_54/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: 1.000000013351432e-10 + } + } + } +} +node { + name: "compute_loss/add_54" + op: "Add" + input: "compute_loss/Slice_55" + input: "compute_loss/add_54/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/truediv_15" + op: "RealDiv" + input: "compute_loss/Slice_54" + input: "compute_loss/add_54" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/concat_149/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/concat_149" + op: "ConcatV2" + input: "compute_loss/truediv_14" + input: "compute_loss/truediv_15" + input: "compute_loss/concat_149/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/Reshape_39/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\020\000\000\0004\000\000\000" + } + } + } +} +node { + name: "compute_loss/Reshape_39" + op: "Reshape" + input: "compute_loss/concat_149" + input: "compute_loss/Reshape_39/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "compute_loss/transpose_15/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\002\000\000\000\003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/transpose_15" + op: "Transpose" + input: "compute_loss/Reshape_39" + input: "compute_loss/transpose_15/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/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: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_7/split/split_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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_7/split" + op: "SplitV" + input: "compute_loss/transpose_15" + input: "compute_loss/image_sampling_7/Const" + input: "compute_loss/image_sampling_7/split/split_dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tlen" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "num_split" + value { + i: 2 + } + } +} +node { + name: "compute_loss/image_sampling_7/Floor" + op: "Floor" + input: "compute_loss/image_sampling_7/split" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/add/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_7/add" + op: "Add" + input: "compute_loss/image_sampling_7/Floor" + input: "compute_loss/image_sampling_7/add/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Floor_1" + op: "Floor" + input: "compute_loss/image_sampling_7/split:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/add_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: 1.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_7/add_1" + op: "Add" + input: "compute_loss/image_sampling_7/Floor_1" + input: "compute_loss/image_sampling_7/add_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_7/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: 1 + } + } + } +} +node { + name: "compute_loss/image_sampling_7/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: 2 + } + } + } +} +node { + name: "compute_loss/image_sampling_7/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: "compute_loss/image_sampling_7/strided_slice" + op: "StridedSlice" + input: "compute_loss/image_sampling_7/Shape" + input: "compute_loss/image_sampling_7/strided_slice/stack" + input: "compute_loss/image_sampling_7/strided_slice/stack_1" + input: "compute_loss/image_sampling_7/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: "compute_loss/image_sampling_7/sub/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "compute_loss/image_sampling_7/sub" + op: "Sub" + input: "compute_loss/image_sampling_7/strided_slice" + input: "compute_loss/image_sampling_7/sub/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Cast_2" + op: "Cast" + input: "compute_loss/image_sampling_7/sub" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_7/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: 2 + } + } + } +} +node { + name: "compute_loss/image_sampling_7/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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_7/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: "compute_loss/image_sampling_7/strided_slice_1" + op: "StridedSlice" + input: "compute_loss/image_sampling_7/Shape_1" + input: "compute_loss/image_sampling_7/strided_slice_1/stack" + input: "compute_loss/image_sampling_7/strided_slice_1/stack_1" + input: "compute_loss/image_sampling_7/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: "compute_loss/image_sampling_7/sub_1/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: "compute_loss/image_sampling_7/sub_1" + op: "Sub" + input: "compute_loss/image_sampling_7/strided_slice_1" + input: "compute_loss/image_sampling_7/sub_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Cast_3" + op: "Cast" + input: "compute_loss/image_sampling_7/sub_1" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/zeros" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "compute_loss/image_sampling_7/clip_by_value/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_7/Floor" + input: "compute_loss/image_sampling_7/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/clip_by_value" + op: "Maximum" + input: "compute_loss/image_sampling_7/clip_by_value/Minimum" + input: "compute_loss/image_sampling_7/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/clip_by_value_1/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_7/Floor_1" + input: "compute_loss/image_sampling_7/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/clip_by_value_1" + op: "Maximum" + input: "compute_loss/image_sampling_7/clip_by_value_1/Minimum" + input: "compute_loss/image_sampling_7/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/clip_by_value_2/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_7/add" + input: "compute_loss/image_sampling_7/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/clip_by_value_2" + op: "Maximum" + input: "compute_loss/image_sampling_7/clip_by_value_2/Minimum" + input: "compute_loss/image_sampling_7/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/clip_by_value_3/Minimum" + op: "Minimum" + input: "compute_loss/image_sampling_7/add_1" + input: "compute_loss/image_sampling_7/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/clip_by_value_3" + op: "Maximum" + input: "compute_loss/image_sampling_7/clip_by_value_3/Minimum" + input: "compute_loss/image_sampling_7/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/sub_2" + op: "Sub" + input: "compute_loss/image_sampling_7/clip_by_value_2" + input: "compute_loss/image_sampling_7/split" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/sub_3" + op: "Sub" + input: "compute_loss/image_sampling_7/split" + input: "compute_loss/image_sampling_7/clip_by_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/sub_4" + op: "Sub" + input: "compute_loss/image_sampling_7/clip_by_value_3" + input: "compute_loss/image_sampling_7/split:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/sub_5" + op: "Sub" + input: "compute_loss/image_sampling_7/split:1" + input: "compute_loss/image_sampling_7/clip_by_value_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Cast_4/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 52 + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Cast_4" + op: "Cast" + input: "compute_loss/image_sampling_7/Cast_4/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Cast_5/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 832 + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Cast_5" + op: "Cast" + input: "compute_loss/image_sampling_7/Cast_5/x" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/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: "compute_loss/image_sampling_7/range/limit" + 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: 4 + } + } + } +} +node { + name: "compute_loss/image_sampling_7/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: "compute_loss/image_sampling_7/range" + op: "Range" + input: "compute_loss/image_sampling_7/range/start" + input: "compute_loss/image_sampling_7/range/limit" + input: "compute_loss/image_sampling_7/range/delta" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Cast_6" + op: "Cast" + input: "compute_loss/image_sampling_7/range" + attr { + key: "DstT" + value { + type: DT_FLOAT + } + } + attr { + key: "SrcT" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/mul" + op: "Mul" + input: "compute_loss/image_sampling_7/Cast_6" + input: "compute_loss/image_sampling_7/Cast_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/stack" + 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: 832 + } + } + } +} +node { + name: "compute_loss/image_sampling_7/stack_1/values_0" + 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: 832 + } + } + } +} +node { + name: "compute_loss/image_sampling_7/stack_1" + op: "Pack" + input: "compute_loss/image_sampling_7/stack_1/values_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: "compute_loss/image_sampling_7/ones/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: "compute_loss/image_sampling_7/ones" + op: "Fill" + input: "compute_loss/image_sampling_7/stack_1" + input: "compute_loss/image_sampling_7/ones/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 832 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "compute_loss/image_sampling_7/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: "compute_loss/image_sampling_7/ExpandDims" + op: "ExpandDims" + input: "compute_loss/image_sampling_7/ones" + input: "compute_loss/image_sampling_7/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: 832 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/transpose/perm" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_7/transpose" + op: "Transpose" + input: "compute_loss/image_sampling_7/ExpandDims" + input: "compute_loss/image_sampling_7/transpose/perm" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Reshape" + op: "Reshape" + input: "compute_loss/image_sampling_7/mul" + input: "compute_loss/image_sampling_7/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: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/MatMul" + op: "MatMul" + input: "compute_loss/image_sampling_7/Reshape" + input: "compute_loss/image_sampling_7/transpose" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "compute_loss/image_sampling_7/Reshape_1/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -1 + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Reshape_1" + op: "Reshape" + input: "compute_loss/image_sampling_7/MatMul" + input: "compute_loss/image_sampling_7/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Reshape_2/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Reshape_2" + op: "Reshape" + input: "compute_loss/image_sampling_7/Reshape_1" + input: "compute_loss/image_sampling_7/Reshape_2/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/mul_1" + op: "Mul" + input: "compute_loss/image_sampling_7/clip_by_value_1" + input: "compute_loss/image_sampling_7/Cast_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/add_2" + op: "Add" + input: "compute_loss/image_sampling_7/Reshape_2" + input: "compute_loss/image_sampling_7/mul_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/mul_2" + op: "Mul" + input: "compute_loss/image_sampling_7/clip_by_value_3" + input: "compute_loss/image_sampling_7/Cast_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/add_3" + op: "Add" + input: "compute_loss/image_sampling_7/Reshape_2" + input: "compute_loss/image_sampling_7/mul_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/add_4" + op: "Add" + input: "compute_loss/image_sampling_7/clip_by_value" + input: "compute_loss/image_sampling_7/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Reshape_3/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: "compute_loss/image_sampling_7/Reshape_3" + op: "Reshape" + input: "compute_loss/image_sampling_7/add_4" + input: "compute_loss/image_sampling_7/Reshape_3/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/add_5" + op: "Add" + input: "compute_loss/image_sampling_7/clip_by_value" + input: "compute_loss/image_sampling_7/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/add_6" + op: "Add" + input: "compute_loss/image_sampling_7/clip_by_value_2" + input: "compute_loss/image_sampling_7/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/add_7" + op: "Add" + input: "compute_loss/image_sampling_7/clip_by_value_2" + input: "compute_loss/image_sampling_7/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/stack_2" + 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: "compute_loss/image_sampling_7/stack_3/values_0" + 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: "compute_loss/image_sampling_7/stack_3/values_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: 3 + } + } + } +} +node { + name: "compute_loss/image_sampling_7/stack_3" + op: "Pack" + input: "compute_loss/image_sampling_7/stack_3/values_0" + input: "compute_loss/image_sampling_7/stack_3/values_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: "compute_loss/image_sampling_7/Reshape_4" + op: "Reshape" + input: "compute_loss/strided_slice_76" + input: "compute_loss/image_sampling_7/stack_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3328 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Cast_9" + op: "Cast" + input: "compute_loss/image_sampling_7/Reshape_3" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/GatherV2/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: "compute_loss/image_sampling_7/GatherV2" + op: "GatherV2" + input: "compute_loss/image_sampling_7/Reshape_4" + input: "compute_loss/image_sampling_7/Cast_9" + input: "compute_loss/image_sampling_7/GatherV2/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3328 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Reshape_5/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Reshape_5" + op: "Reshape" + input: "compute_loss/image_sampling_7/GatherV2" + input: "compute_loss/image_sampling_7/Reshape_5/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Cast_10" + op: "Cast" + input: "compute_loss/image_sampling_7/add_5" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/GatherV2_1/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: "compute_loss/image_sampling_7/GatherV2_1" + op: "GatherV2" + input: "compute_loss/image_sampling_7/Reshape_4" + input: "compute_loss/image_sampling_7/Cast_10" + input: "compute_loss/image_sampling_7/GatherV2_1/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Reshape_6/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Reshape_6" + op: "Reshape" + input: "compute_loss/image_sampling_7/GatherV2_1" + input: "compute_loss/image_sampling_7/Reshape_6/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Cast_11" + op: "Cast" + input: "compute_loss/image_sampling_7/add_6" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/GatherV2_2/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: "compute_loss/image_sampling_7/GatherV2_2" + op: "GatherV2" + input: "compute_loss/image_sampling_7/Reshape_4" + input: "compute_loss/image_sampling_7/Cast_11" + input: "compute_loss/image_sampling_7/GatherV2_2/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Reshape_7/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Reshape_7" + op: "Reshape" + input: "compute_loss/image_sampling_7/GatherV2_2" + input: "compute_loss/image_sampling_7/Reshape_7/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Cast_12" + op: "Cast" + input: "compute_loss/image_sampling_7/add_7" + attr { + key: "DstT" + value { + type: DT_INT32 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/GatherV2_3/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: "compute_loss/image_sampling_7/GatherV2_3" + op: "GatherV2" + input: "compute_loss/image_sampling_7/Reshape_4" + input: "compute_loss/image_sampling_7/Cast_12" + input: "compute_loss/image_sampling_7/GatherV2_3/axis" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT32 + } + } + attr { + key: "Tparams" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Reshape_8/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/image_sampling_7/Reshape_8" + op: "Reshape" + input: "compute_loss/image_sampling_7/GatherV2_3" + input: "compute_loss/image_sampling_7/Reshape_8/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/mul_3" + op: "Mul" + input: "compute_loss/image_sampling_7/sub_2" + input: "compute_loss/image_sampling_7/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/mul_4" + op: "Mul" + input: "compute_loss/image_sampling_7/sub_2" + input: "compute_loss/image_sampling_7/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/mul_5" + op: "Mul" + input: "compute_loss/image_sampling_7/sub_3" + input: "compute_loss/image_sampling_7/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/mul_6" + op: "Mul" + input: "compute_loss/image_sampling_7/sub_3" + input: "compute_loss/image_sampling_7/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/mul_7" + op: "Mul" + input: "compute_loss/image_sampling_7/mul_3" + input: "compute_loss/image_sampling_7/Reshape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/mul_8" + op: "Mul" + input: "compute_loss/image_sampling_7/mul_4" + input: "compute_loss/image_sampling_7/Reshape_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/mul_9" + op: "Mul" + input: "compute_loss/image_sampling_7/mul_5" + input: "compute_loss/image_sampling_7/Reshape_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/mul_10" + op: "Mul" + input: "compute_loss/image_sampling_7/mul_6" + input: "compute_loss/image_sampling_7/Reshape_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/image_sampling_7/AddN" + op: "AddN" + input: "compute_loss/image_sampling_7/mul_7" + input: "compute_loss/image_sampling_7/mul_8" + input: "compute_loss/image_sampling_7/mul_9" + input: "compute_loss/image_sampling_7/mul_10" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/sub_31" + op: "Sub" + input: "compute_loss/image_sampling_7/AddN" + input: "compute_loss/ResizeArea_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Abs_23" + op: "Abs" + input: "compute_loss/sub_31" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "compute_loss/Const_39" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\001\000\000\000\002\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "compute_loss/Mean_23" + op: "Mean" + input: "compute_loss/Abs_23" + input: "compute_loss/Const_39" + 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: "compute_loss/add_55" + op: "Add" + input: "compute_loss/add_50" + input: "compute_loss/Mean_23" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/concat_150/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_150" + op: "ConcatV2" + input: "compute_loss/image_sampling_6/AddN" + input: "compute_loss/image_sampling_7/AddN" + input: "compute_loss/concat_150/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "compute_loss/concat_151/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: 3 + } + } + } +} +node { + name: "compute_loss/concat_151" + op: "ConcatV2" + input: "compute_loss/Abs_22" + input: "compute_loss/Abs_23" + input: "compute_loss/concat_151/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "compute_loss/add_56" + op: "Add" + input: "compute_loss/add_55" + input: "compute_loss/add_45" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "compute_loss/add_57/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: "compute_loss/add_57" + op: "Add" + input: "compute_loss/add_56" + input: "compute_loss/add_57/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +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: "train_op/gradients/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/grad_ys_0" + 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: "train_op/gradients/Fill" + op: "Fill" + input: "train_op/gradients/Shape" + input: "train_op/gradients/grad_ys_0" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/add_57_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/Fill" +} +node { + name: "train_op/gradients/compute_loss/add_57_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/Fill" + input: "^train_op/gradients/compute_loss/add_57_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_57_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/Fill" + input: "^train_op/gradients/compute_loss/add_57_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_56_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_57_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_56_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_57_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_56_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_56_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_57_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_56_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_55_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_56_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_55_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_56_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_55_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_55_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_56_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_55_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_45_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_56_grad/tuple/control_dependency_1" +} +node { + name: "train_op/gradients/compute_loss/add_45_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_56_grad/tuple/control_dependency_1" + input: "^train_op/gradients/compute_loss/add_45_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_45_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_56_grad/tuple/control_dependency_1" + input: "^train_op/gradients/compute_loss/add_45_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_50_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_55_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_50_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_55_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_50_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_50_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_55_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_50_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_23_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_23_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_55_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_23_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_23_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_23_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_23_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_23_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_23_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 9984.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_23_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_23_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_23_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_31_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_45_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_31_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_45_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_31_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_31_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_45_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_31_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_33_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/add_45_grad/tuple/control_dependency_1" + input: "compute_loss/add_44" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_33_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/add_45_grad/tuple/control_dependency_1" + input: "compute_loss/mul_33/x" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_33_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/mul_33_grad/Mul" + input: "^train_op/gradients/compute_loss/mul_33_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/mul_33_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_33_grad/Mul" + input: "^train_op/gradients/compute_loss/mul_33_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_33_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_33_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_33_grad/Mul_1" + input: "^train_op/gradients/compute_loss/mul_33_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_33_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_41_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_50_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_41_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_50_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_41_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_41_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_50_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_41_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_22_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_22_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_50_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_22_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_22_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_22_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_22_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_22_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_22_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 9984.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_22_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_22_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_22_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_23_grad/Sign" + op: "Sign" + input: "compute_loss/sub_31" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_23_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_23_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_23_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_17_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_31_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_17_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_31_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_17_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_17_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_31_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_17_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_22_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/add_31_grad/tuple/control_dependency_1" + input: "compute_loss/add_30" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_22_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/add_31_grad/tuple/control_dependency_1" + input: "compute_loss/mul_22/x" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_22_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/mul_22_grad/Mul" + input: "^train_op/gradients/compute_loss/mul_22_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/mul_22_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_22_grad/Mul" + input: "^train_op/gradients/compute_loss/mul_22_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_22_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_22_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_22_grad/Mul_1" + input: "^train_op/gradients/compute_loss/mul_22_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_22_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_44_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/mul_33_grad/tuple/control_dependency_1" +} +node { + name: "train_op/gradients/compute_loss/add_44_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_33_grad/tuple/control_dependency_1" + input: "^train_op/gradients/compute_loss/add_44_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_33_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_44_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_33_grad/tuple/control_dependency_1" + input: "^train_op/gradients/compute_loss/add_44_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_33_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_36_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_41_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_36_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_41_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_36_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_36_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_41_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_36_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_17_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_17_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_41_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_17_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_17_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_17_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_17_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_17_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_17_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 39936.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_17_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_17_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_17_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_22_grad/Sign" + op: "Sign" + input: "compute_loss/sub_30" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_22_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_22_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_22_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_31_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_23_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_31_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_23_grad/mul" + input: "^train_op/gradients/compute_loss/sub_31_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_31_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_23_grad/mul" + input: "^train_op/gradients/compute_loss/sub_31_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_23_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_31_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_31_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_31_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_31_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_17_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_17_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_17_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_11_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/add_17_grad/tuple/control_dependency_1" + input: "compute_loss/add_16" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_11_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/add_17_grad/tuple/control_dependency_1" + input: "compute_loss/mul_11/x" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_11_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/mul_11_grad/Mul" + input: "^train_op/gradients/compute_loss/mul_11_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/mul_11_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_11_grad/Mul" + input: "^train_op/gradients/compute_loss/mul_11_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_11_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_11_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_11_grad/Mul_1" + input: "^train_op/gradients/compute_loss/mul_11_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_11_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_30_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/mul_22_grad/tuple/control_dependency_1" +} +node { + name: "train_op/gradients/compute_loss/add_30_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_22_grad/tuple/control_dependency_1" + input: "^train_op/gradients/compute_loss/add_30_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_22_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_30_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_22_grad/tuple/control_dependency_1" + input: "^train_op/gradients/compute_loss/add_30_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_22_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_43_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_44_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_43_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_44_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_43_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_33_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_43_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_44_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_43_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_33_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_21_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_21_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_44_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_21_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_21_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\016\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_21_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_21_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_21_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 14 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_21_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2912.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_21_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_21_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_21_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 14 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_27_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_36_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_27_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_36_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_27_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_27_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_36_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_27_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_16_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_16_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_36_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_16_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_16_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_16_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_16_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_16_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_16_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 39936.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_16_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_16_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_16_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_17_grad/Sign" + op: "Sign" + input: "compute_loss/sub_23" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_17_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_17_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_17_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_30_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_22_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_30_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_22_grad/mul" + input: "^train_op/gradients/compute_loss/sub_30_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_30_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_22_grad/mul" + input: "^train_op/gradients/compute_loss/sub_30_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_22_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_30_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_30_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_30_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_30_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/AddN_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/sub_31_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/AddN_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_31_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_7/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_23_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/AddN_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_31_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_7/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_23_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/AddN_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_31_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_7/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_23_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/AddN_grad/tuple/control_dependency_3" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_31_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_7/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_23_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/add_3_grad/tuple/control_dependency_1" + input: "compute_loss/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/add_3_grad/tuple/control_dependency_1" + input: "compute_loss/mul/x" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/mul_grad/Mul" + input: "^train_op/gradients/compute_loss/mul_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/mul_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_grad/Mul" + input: "^train_op/gradients/compute_loss/mul_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_grad/Mul_1" + input: "^train_op/gradients/compute_loss/mul_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_16_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/mul_11_grad/tuple/control_dependency_1" +} +node { + name: "train_op/gradients/compute_loss/add_16_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_11_grad/tuple/control_dependency_1" + input: "^train_op/gradients/compute_loss/add_16_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_11_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_16_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_11_grad/tuple/control_dependency_1" + input: "^train_op/gradients/compute_loss/add_16_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_11_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_29_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_30_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_29_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_30_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_29_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_22_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_29_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_30_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_29_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_22_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_15_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_15_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_30_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_15_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_15_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\036\000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_15_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_15_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_15_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 30 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_15_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 12480.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_15_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_15_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_15_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 30 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_42_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_43_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_42_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_43_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_42_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_33_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_42_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_43_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_42_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_33_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_20_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_20_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_43_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_20_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_20_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\017\000\000\0003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_20_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_20_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_20_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_20_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 3060.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_20_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_20_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_20_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_21_grad/Sign" + op: "Sign" + input: "compute_loss/sub_28" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 14 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_21_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_21_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_21_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 14 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_22_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_27_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_22_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_27_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_22_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_22_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_27_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_22_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_11_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_11_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_27_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_11_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_11_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_11_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_11_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_11_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_11_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 159744.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_11_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_11_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_11_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_16_grad/Sign" + op: "Sign" + input: "compute_loss/sub_22" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_16_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_16_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_16_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_23_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_17_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_23_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_17_grad/mul" + input: "^train_op/gradients/compute_loss/sub_23_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_23_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_17_grad/mul" + input: "^train_op/gradients/compute_loss/sub_23_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_17_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_23_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_23_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_23_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_23_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/AddN_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/sub_30_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/AddN_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_30_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_6/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_22_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/AddN_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_30_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_6/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_22_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/AddN_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_30_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_6/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_22_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/AddN_grad/tuple/control_dependency_3" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_30_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_6/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_22_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_7/AddN_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_7/Reshape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_7/mul_3" + input: "train_op/gradients/compute_loss/image_sampling_7/AddN_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_7/AddN_grad/tuple/control_dependency_1" + input: "compute_loss/image_sampling_7/Reshape_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_7/mul_4" + input: "train_op/gradients/compute_loss/image_sampling_7/AddN_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_7/AddN_grad/tuple/control_dependency_2" + input: "compute_loss/image_sampling_7/Reshape_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_7/mul_5" + input: "train_op/gradients/compute_loss/image_sampling_7/AddN_grad/tuple/control_dependency_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_7/AddN_grad/tuple/control_dependency_3" + input: "compute_loss/image_sampling_7/Reshape_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_7/mul_6" + input: "train_op/gradients/compute_loss/image_sampling_7/AddN_grad/tuple/control_dependency_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/mul_grad/tuple/control_dependency_1" +} +node { + name: "train_op/gradients/compute_loss/add_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_grad/tuple/control_dependency_1" + input: "^train_op/gradients/compute_loss/add_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_grad/tuple/control_dependency_1" + input: "^train_op/gradients/compute_loss/add_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_15_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_16_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_15_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_16_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_15_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_11_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_15_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_16_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_15_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_11_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_9_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_9_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_16_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_9_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_9_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000>\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_9_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_9_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_9_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 62 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_9_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 51584.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_9_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_9_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_9_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 62 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_28_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_29_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_28_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_29_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_28_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_22_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_28_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_29_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_28_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_22_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_14_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_14_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_29_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_14_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_14_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\037\000\000\000g\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_14_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_14_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_14_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_14_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 12772.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_14_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_14_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_14_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_15_grad/Sign" + op: "Sign" + input: "compute_loss/sub_20" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 30 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_15_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_15_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_15_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 30 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_18_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_18_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_42_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Mean_18_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_18_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0002\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_18_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_18_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_18_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 50 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_18_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 3200.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_18_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_18_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_18_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 50 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_19_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_19_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_42_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_19_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_19_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\017\000\000\0003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_19_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_19_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_19_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_19_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 3060.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_19_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_19_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_19_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_20_grad/Sign" + op: "Sign" + input: "compute_loss/sub_29" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_20_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_20_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_20_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_28_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_21_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 14 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_28_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_21_grad/mul" + input: "^train_op/gradients/compute_loss/sub_28_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_28_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_21_grad/mul" + input: "^train_op/gradients/compute_loss/sub_28_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_21_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 14 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_28_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_28_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_28_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_28_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 14 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_13_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_22_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_13_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_22_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_13_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_13_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_22_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_13_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_10_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_10_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_22_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_10_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_10_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_10_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_10_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_10_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_10_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 159744.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_10_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_10_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_10_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_11_grad/Sign" + op: "Sign" + input: "compute_loss/sub_15" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_11_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_11_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_11_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_22_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_16_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_22_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_16_grad/mul" + input: "^train_op/gradients/compute_loss/sub_22_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_22_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_16_grad/mul" + input: "^train_op/gradients/compute_loss/sub_22_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_16_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_22_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_22_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_22_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_22_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/AddN_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/sub_23_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/AddN_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_23_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_5/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_17_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/AddN_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_23_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_5/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_17_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/AddN_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_23_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_5/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_17_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/AddN_grad/tuple/control_dependency_3" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_23_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_5/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_17_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_6/AddN_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_6/Reshape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_6/mul_3" + input: "train_op/gradients/compute_loss/image_sampling_6/AddN_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_6/AddN_grad/tuple/control_dependency_1" + input: "compute_loss/image_sampling_6/Reshape_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_6/mul_4" + input: "train_op/gradients/compute_loss/image_sampling_6/AddN_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_6/AddN_grad/tuple/control_dependency_2" + input: "compute_loss/image_sampling_6/Reshape_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_6/mul_5" + input: "train_op/gradients/compute_loss/image_sampling_6/AddN_grad/tuple/control_dependency_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_6/AddN_grad/tuple/control_dependency_3" + input: "compute_loss/image_sampling_6/Reshape_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_6/mul_6" + input: "train_op/gradients/compute_loss/image_sampling_6/AddN_grad/tuple/control_dependency_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_3_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_7/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_3_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_7_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_7/sub_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_3_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_3_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_3_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_3_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_4_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_7/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_4_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_8_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_7/sub_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_4_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_4_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_4_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_4_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_4_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_5_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_7/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_5_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_9_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_7/sub_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_5_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_5_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_5_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_5_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_5_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_6_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_7/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_6_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_10_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_7/sub_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_6_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_6_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_6_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_6_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_6_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_6_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/mul_6_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_6_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/mul_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_6_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_2_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_2_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_2_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_3_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_3_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_2_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_3_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_3_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000~\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_3_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_3_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_3_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 126 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_3_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 209664.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_3_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_3_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_3_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 126 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_14_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_15_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_14_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_15_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_14_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_11_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_14_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_15_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_14_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_11_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_8_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_8_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_15_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_8_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_8_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000?\000\000\000\317\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_8_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_8_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_8_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_8_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 52164.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_8_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_8_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_8_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_9_grad/Sign" + op: "Sign" + input: "compute_loss/sub_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 62 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_9_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_9_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_9_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 62 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_12_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_12_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_28_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Mean_12_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_12_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000f\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_12_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_12_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_12_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 102 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_12_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 13056.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_12_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_12_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_12_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 102 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_13_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_13_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_28_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_13_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_13_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\037\000\000\000g\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_13_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_13_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_13_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_13_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 12772.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_13_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_13_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_13_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_14_grad/Sign" + op: "Sign" + input: "compute_loss/sub_21" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_14_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_14_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_14_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_20_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_15_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 30 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_20_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_15_grad/mul" + input: "^train_op/gradients/compute_loss/sub_20_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_20_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_15_grad/mul" + input: "^train_op/gradients/compute_loss/sub_20_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_15_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 30 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_20_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_20_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_20_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_20_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 30 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_18_grad/Sign" + op: "Sign" + input: "compute_loss/sub_27" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 50 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_18_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_18_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_18_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 50 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_19_grad/Sign" + op: "Sign" + input: "compute_loss/sub_26" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_19_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_19_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_19_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_29_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_20_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_29_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_20_grad/mul" + input: "^train_op/gradients/compute_loss/sub_29_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_29_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_20_grad/mul" + input: "^train_op/gradients/compute_loss/sub_29_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_20_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_29_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_29_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_29_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_29_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_68_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\017\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_68_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_68_grad/Shape" + input: "compute_loss/strided_slice_68/stack" + input: "compute_loss/strided_slice_68/stack_1" + input: "compute_loss/strided_slice_68/stack_2" + input: "train_op/gradients/compute_loss/sub_28_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_69_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\017\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_69_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_69_grad/Shape" + input: "compute_loss/strided_slice_69/stack" + input: "compute_loss/strided_slice_69/stack_1" + input: "compute_loss/strided_slice_69/stack_2" + input: "train_op/gradients/compute_loss/sub_28_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/add_8_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_13_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_8_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_13_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_8_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_13_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/Fill" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_5_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_5_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_13_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_5_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_5_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_5_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_5_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_5_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_5_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 638976.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_5_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_5_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_5_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_10_grad/Sign" + op: "Sign" + input: "compute_loss/sub_14" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_10_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_10_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_10_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_15_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_11_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_15_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_11_grad/mul" + input: "^train_op/gradients/compute_loss/sub_15_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_15_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_11_grad/mul" + input: "^train_op/gradients/compute_loss/sub_15_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_11_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_15_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_15_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_15_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_15_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/AddN_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/sub_22_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/AddN_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_22_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_4/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_16_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/AddN_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_22_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_4/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_16_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/AddN_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_22_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_4/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_16_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/AddN_grad/tuple/control_dependency_3" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_22_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_4/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_16_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_5/AddN_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_5/Reshape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_5/mul_3" + input: "train_op/gradients/compute_loss/image_sampling_5/AddN_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_5/AddN_grad/tuple/control_dependency_1" + input: "compute_loss/image_sampling_5/Reshape_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_5/mul_4" + input: "train_op/gradients/compute_loss/image_sampling_5/AddN_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_5/AddN_grad/tuple/control_dependency_2" + input: "compute_loss/image_sampling_5/Reshape_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_5/mul_5" + input: "train_op/gradients/compute_loss/image_sampling_5/AddN_grad/tuple/control_dependency_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_5/AddN_grad/tuple/control_dependency_3" + input: "compute_loss/image_sampling_5/Reshape_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_5/mul_6" + input: "train_op/gradients/compute_loss/image_sampling_5/AddN_grad/tuple/control_dependency_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_3_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_6/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_3_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_7_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_6/sub_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_3_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_3_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_3_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_3_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_4_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_6/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_4_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_8_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_6/sub_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_4_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_4_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_4_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_4_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_4_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_5_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_6/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_5_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_9_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_6/sub_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_5_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_5_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_5_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_5_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_5_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_6_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_6/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_6_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_10_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_6/sub_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_6_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_6_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_6_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_6_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_6_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_6_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/mul_6_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_6_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_6/mul_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_6_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_4_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/sub_2_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/sub_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN" + input: "^train_op/gradients/compute_loss/image_sampling_7/sub_2_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/sub_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN" + input: "^train_op/gradients/compute_loss/image_sampling_7/sub_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/sub_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/sub_2_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_7/sub_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/sub_2_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_1" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_5_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/sub_4_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/sub_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/sub_4_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/sub_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/sub_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/sub_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/sub_4_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_7/sub_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/sub_4_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_2" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_5_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_6_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/sub_3_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/sub_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_2" + input: "^train_op/gradients/compute_loss/image_sampling_7/sub_3_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/sub_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_2" + input: "^train_op/gradients/compute_loss/image_sampling_7/sub_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/sub_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/sub_3_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_7/sub_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/sub_3_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_3" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_4_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_7/mul_6_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/sub_5_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/sub_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_3" + input: "^train_op/gradients/compute_loss/image_sampling_7/sub_5_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/sub_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_3" + input: "^train_op/gradients/compute_loss/image_sampling_7/sub_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/sub_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/sub_5_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_7/sub_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/sub_5_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_1_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/add_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_1_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_1_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_2_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_2_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_1_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_2_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_2_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\177\000\000\000\237\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_2_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_2_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_2_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_2_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 210820.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_2_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_2_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_2_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_3_grad/Sign" + op: "Sign" + input: "compute_loss/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 126 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_3_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_3_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_3_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 126 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_6_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_6_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_14_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Mean_6_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_6_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\316\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_6_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_6_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_6_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 206 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_6_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 52736.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_6_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_6_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_6_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 206 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_7_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_7_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_14_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_7_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_7_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000?\000\000\000\317\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_7_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_7_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_7_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_7_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 52164.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_7_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_7_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_7_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_8_grad/Sign" + op: "Sign" + input: "compute_loss/sub_13" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_8_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_8_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_8_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_12_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_9_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 62 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_12_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_9_grad/mul" + input: "^train_op/gradients/compute_loss/sub_12_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_12_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_9_grad/mul" + input: "^train_op/gradients/compute_loss/sub_12_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_9_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 62 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_12_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_12_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_12_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_12_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 62 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_12_grad/Sign" + op: "Sign" + input: "compute_loss/sub_19" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 102 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_12_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_12_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_12_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 102 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_13_grad/Sign" + op: "Sign" + input: "compute_loss/sub_18" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_13_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_13_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_13_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_21_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_14_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_21_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_14_grad/mul" + input: "^train_op/gradients/compute_loss/sub_21_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_21_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_14_grad/mul" + input: "^train_op/gradients/compute_loss/sub_21_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_14_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_21_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_21_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_21_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_21_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_48_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\037\000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_48_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_48_grad/Shape" + input: "compute_loss/strided_slice_48/stack" + input: "compute_loss/strided_slice_48/stack_1" + input: "compute_loss/strided_slice_48/stack_2" + input: "train_op/gradients/compute_loss/sub_20_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_49_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\037\000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_49_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_49_grad/Shape" + input: "compute_loss/strided_slice_49/stack" + input: "compute_loss/strided_slice_49/stack_1" + input: "compute_loss/strided_slice_49/stack_2" + input: "train_op/gradients/compute_loss/sub_20_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_27_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_18_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 50 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_27_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_18_grad/mul" + input: "^train_op/gradients/compute_loss/sub_27_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_27_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_18_grad/mul" + input: "^train_op/gradients/compute_loss/sub_27_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_18_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 50 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_27_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_27_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_27_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_27_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 50 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_26_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_19_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_26_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_19_grad/mul" + input: "^train_op/gradients/compute_loss/sub_26_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_26_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_19_grad/mul" + input: "^train_op/gradients/compute_loss/sub_26_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_19_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_26_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_26_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_26_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_26_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_70_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\017\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_70_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_70_grad/Shape" + input: "compute_loss/strided_slice_70/stack" + input: "compute_loss/strided_slice_70/stack_1" + input: "compute_loss/strided_slice_70/stack_2" + input: "train_op/gradients/compute_loss/sub_29_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_71_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\017\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_71_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_71_grad/Shape" + input: "compute_loss/strided_slice_71/stack" + input: "compute_loss/strided_slice_71/stack_1" + input: "compute_loss/strided_slice_71/stack_2" + input: "train_op/gradients/compute_loss/sub_29_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_4_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_4_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_8_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_4_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_4_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_4_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_4_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_4_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_4_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 638976.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_4_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_4_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_4_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_5_grad/Sign" + op: "Sign" + input: "compute_loss/sub_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_5_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_5_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_5_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_14_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_10_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_14_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_10_grad/mul" + input: "^train_op/gradients/compute_loss/sub_14_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_14_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_10_grad/mul" + input: "^train_op/gradients/compute_loss/sub_14_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_10_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_14_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_14_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_14_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_14_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/AddN_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/sub_15_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/AddN_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_15_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_3/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_11_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/AddN_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_15_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_3/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_11_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/AddN_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_15_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_3/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_11_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/AddN_grad/tuple/control_dependency_3" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_15_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_3/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_11_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_4/AddN_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_4/Reshape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_4/mul_3" + input: "train_op/gradients/compute_loss/image_sampling_4/AddN_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_4/AddN_grad/tuple/control_dependency_1" + input: "compute_loss/image_sampling_4/Reshape_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_4/mul_4" + input: "train_op/gradients/compute_loss/image_sampling_4/AddN_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_4/AddN_grad/tuple/control_dependency_2" + input: "compute_loss/image_sampling_4/Reshape_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_4/mul_5" + input: "train_op/gradients/compute_loss/image_sampling_4/AddN_grad/tuple/control_dependency_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_4/AddN_grad/tuple/control_dependency_3" + input: "compute_loss/image_sampling_4/Reshape_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_4/mul_6" + input: "train_op/gradients/compute_loss/image_sampling_4/AddN_grad/tuple/control_dependency_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_3_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_5/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_3_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_7_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_5/sub_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_3_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_3_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_3_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_3_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_4_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_5/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_4_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_8_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_5/sub_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_4_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_4_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_4_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_4_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_4_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_5_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_5/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_5_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_9_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_5/sub_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_5_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_5_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_5_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_5_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_5_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_6_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_5/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_6_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_10_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_5/sub_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_6_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_6_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_6_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_6_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_6_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_6_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/mul_6_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_6_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_5/mul_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_6_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_4" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_4_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/sub_2_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/sub_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_4" + input: "^train_op/gradients/compute_loss/image_sampling_6/sub_2_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/sub_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_4" + input: "^train_op/gradients/compute_loss/image_sampling_6/sub_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/sub_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/sub_2_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_6/sub_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/sub_2_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_5" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_5_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/sub_4_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/sub_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_5" + input: "^train_op/gradients/compute_loss/image_sampling_6/sub_4_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/sub_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_5" + input: "^train_op/gradients/compute_loss/image_sampling_6/sub_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/sub_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/sub_4_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_6/sub_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/sub_4_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_6" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_5_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_6_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/sub_3_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/sub_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_6" + input: "^train_op/gradients/compute_loss/image_sampling_6/sub_3_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/sub_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_6" + input: "^train_op/gradients/compute_loss/image_sampling_6/sub_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/sub_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/sub_3_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_6/sub_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/sub_3_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_7" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_4_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_6/mul_6_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/sub_5_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/sub_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_7" + input: "^train_op/gradients/compute_loss/image_sampling_6/sub_5_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/sub_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_7" + input: "^train_op/gradients/compute_loss/image_sampling_6/sub_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/sub_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/sub_5_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_6/sub_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/sub_5_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_7/clip_by_value_2/Minimum" + input: "compute_loss/image_sampling_7/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_7/sub_2_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_7/sub_2_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_7/clip_by_value_3/Minimum" + input: "compute_loss/image_sampling_7/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_7/sub_4_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_7/sub_4_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_7/clip_by_value/Minimum" + input: "compute_loss/image_sampling_7/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_7/sub_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_7/sub_3_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_7/clip_by_value_1/Minimum" + input: "compute_loss/image_sampling_7/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_7/sub_5_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_7/sub_5_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Mean_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\236\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 414 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 211968.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 414 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_1_grad/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Mean_1_grad/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_1_grad/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\177\000\000\000\237\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_1_grad/Tile" + op: "Tile" + input: "train_op/gradients/compute_loss/Mean_1_grad/Reshape" + input: "train_op/gradients/compute_loss/Mean_1_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_1_grad/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 210820.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Mean_1_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/Mean_1_grad/Tile" + input: "train_op/gradients/compute_loss/Mean_1_grad/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_2_grad/Sign" + op: "Sign" + input: "compute_loss/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_2_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_2_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_2_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_4_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_3_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 126 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_3_grad/mul" + input: "^train_op/gradients/compute_loss/sub_4_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_3_grad/mul" + input: "^train_op/gradients/compute_loss/sub_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_3_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 126 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_4_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_4_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 126 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_6_grad/Sign" + op: "Sign" + input: "compute_loss/sub_11" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 206 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_6_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_6_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_6_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 206 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_7_grad/Sign" + op: "Sign" + input: "compute_loss/sub_10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_7_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_7_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_7_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_13_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_8_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_13_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_8_grad/mul" + input: "^train_op/gradients/compute_loss/sub_13_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_13_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_8_grad/mul" + input: "^train_op/gradients/compute_loss/sub_13_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_8_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_13_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_13_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_13_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_13_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_28_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000?\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_28_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_28_grad/Shape" + input: "compute_loss/strided_slice_28/stack" + input: "compute_loss/strided_slice_28/stack_1" + input: "compute_loss/strided_slice_28/stack_2" + input: "train_op/gradients/compute_loss/sub_12_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_29_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000?\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_29_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_29_grad/Shape" + input: "compute_loss/strided_slice_29/stack" + input: "compute_loss/strided_slice_29/stack_1" + input: "compute_loss/strided_slice_29/stack_2" + input: "train_op/gradients/compute_loss/sub_12_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_19_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_12_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 102 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_19_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_12_grad/mul" + input: "^train_op/gradients/compute_loss/sub_19_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_19_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_12_grad/mul" + input: "^train_op/gradients/compute_loss/sub_19_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_12_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 102 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_19_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_19_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_19_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_19_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 102 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_18_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_13_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_18_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_13_grad/mul" + input: "^train_op/gradients/compute_loss/sub_18_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_18_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_13_grad/mul" + input: "^train_op/gradients/compute_loss/sub_18_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_13_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_18_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_18_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_18_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_18_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_50_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\037\000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_50_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_50_grad/Shape" + input: "compute_loss/strided_slice_50/stack" + input: "compute_loss/strided_slice_50/stack_1" + input: "compute_loss/strided_slice_50/stack_2" + input: "train_op/gradients/compute_loss/sub_21_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_51_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\037\000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_51_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_51_grad/Shape" + input: "compute_loss/strided_slice_51/stack" + input: "compute_loss/strided_slice_51/stack_1" + input: "compute_loss/strided_slice_51/stack_2" + input: "train_op/gradients/compute_loss/sub_21_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_66_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_66_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_66_grad/Shape" + input: "compute_loss/strided_slice_66/stack" + input: "compute_loss/strided_slice_66/stack_1" + input: "compute_loss/strided_slice_66/stack_2" + input: "train_op/gradients/compute_loss/sub_27_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_67_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_67_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_67_grad/Shape" + input: "compute_loss/strided_slice_67/stack" + input: "compute_loss/strided_slice_67/stack_1" + input: "compute_loss/strided_slice_67/stack_2" + input: "train_op/gradients/compute_loss/sub_27_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_64_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_64_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_64_grad/Shape" + input: "compute_loss/strided_slice_64/stack" + input: "compute_loss/strided_slice_64/stack_1" + input: "compute_loss/strided_slice_64/stack_2" + input: "train_op/gradients/compute_loss/sub_26_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_65_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_65_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_65_grad/Shape" + input: "compute_loss/strided_slice_65/stack" + input: "compute_loss/strided_slice_65/stack_1" + input: "compute_loss/strided_slice_65/stack_2" + input: "train_op/gradients/compute_loss/sub_26_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/AddN_8" + op: "AddN" + input: "train_op/gradients/compute_loss/strided_slice_68_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_69_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_70_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_71_grad/StridedSliceGrad" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_68_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_24_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_24_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_8" + input: "^train_op/gradients/compute_loss/sub_24_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_24_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_8" + input: "^train_op/gradients/compute_loss/sub_24_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_68_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_24_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_24_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_24_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_24_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 15 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_4_grad/Sign" + op: "Sign" + input: "compute_loss/sub_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_4_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_4_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_4_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_7_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_5_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_7_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_5_grad/mul" + input: "^train_op/gradients/compute_loss/sub_7_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_7_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_5_grad/mul" + input: "^train_op/gradients/compute_loss/sub_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_5_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_7_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_7_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_7_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/AddN_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/sub_14_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/AddN_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_14_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_2/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_10_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/AddN_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_14_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_2/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_10_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/AddN_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_14_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_2/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_10_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/AddN_grad/tuple/control_dependency_3" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_14_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_2/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_10_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_3/AddN_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_3/Reshape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_3/mul_3" + input: "train_op/gradients/compute_loss/image_sampling_3/AddN_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_3/AddN_grad/tuple/control_dependency_1" + input: "compute_loss/image_sampling_3/Reshape_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_3/mul_4" + input: "train_op/gradients/compute_loss/image_sampling_3/AddN_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_3/AddN_grad/tuple/control_dependency_2" + input: "compute_loss/image_sampling_3/Reshape_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_3/mul_5" + input: "train_op/gradients/compute_loss/image_sampling_3/AddN_grad/tuple/control_dependency_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_3/AddN_grad/tuple/control_dependency_3" + input: "compute_loss/image_sampling_3/Reshape_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_3/mul_6" + input: "train_op/gradients/compute_loss/image_sampling_3/AddN_grad/tuple/control_dependency_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_3_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_4/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_3_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_7_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_4/sub_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_3_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_3_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_3_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_3_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_4_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_4/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_4_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_8_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_4/sub_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_4_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_4_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_4_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_4_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_4_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_5_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_4/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_5_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_9_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_4/sub_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_5_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_5_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_5_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_5_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_5_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_6_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_4/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_6_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_10_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_4/sub_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_6_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_6_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_6_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_6_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_6_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_6_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/mul_6_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_6_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_4/mul_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_6_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_9" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_4_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/sub_2_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_9" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/sub_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_9" + input: "^train_op/gradients/compute_loss/image_sampling_5/sub_2_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/sub_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_9" + input: "^train_op/gradients/compute_loss/image_sampling_5/sub_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/sub_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/sub_2_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_5/sub_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/sub_2_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_10" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_5_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/sub_4_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/sub_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_10" + input: "^train_op/gradients/compute_loss/image_sampling_5/sub_4_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/sub_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_10" + input: "^train_op/gradients/compute_loss/image_sampling_5/sub_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/sub_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/sub_4_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_5/sub_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/sub_4_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_11" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_5_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_6_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/sub_3_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_11" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/sub_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_11" + input: "^train_op/gradients/compute_loss/image_sampling_5/sub_3_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/sub_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_11" + input: "^train_op/gradients/compute_loss/image_sampling_5/sub_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/sub_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/sub_3_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_5/sub_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/sub_3_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_12" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_4_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_5/mul_6_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/sub_5_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/sub_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_12" + input: "^train_op/gradients/compute_loss/image_sampling_5/sub_5_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/sub_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_12" + input: "^train_op/gradients/compute_loss/image_sampling_5/sub_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/sub_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/sub_5_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_5/sub_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/sub_5_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_6/clip_by_value_2/Minimum" + input: "compute_loss/image_sampling_6/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_6/sub_2_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_6/sub_2_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_6/clip_by_value_3/Minimum" + input: "compute_loss/image_sampling_6/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_6/sub_4_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_6/sub_4_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_6/clip_by_value/Minimum" + input: "compute_loss/image_sampling_6/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_6/sub_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_6/sub_3_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_6/clip_by_value_1/Minimum" + input: "compute_loss/image_sampling_6/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_6/sub_5_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_6/sub_5_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_7/add" + input: "compute_loss/image_sampling_7/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_7/add_1" + input: "compute_loss/image_sampling_7/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_7/Floor" + input: "compute_loss/image_sampling_7/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_7/Floor_1" + input: "compute_loss/image_sampling_7/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_grad/Sign" + op: "Sign" + input: "compute_loss/sub_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 414 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 414 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_1_grad/Sign" + op: "Sign" + input: "compute_loss/sub_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Abs_1_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Mean_1_grad/truediv" + input: "train_op/gradients/compute_loss/Abs_1_grad/Sign" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_5_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_2_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_2_grad/mul" + input: "^train_op/gradients/compute_loss/sub_5_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_2_grad/mul" + input: "^train_op/gradients/compute_loss/sub_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_2_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_5_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_5_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_8_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\177\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_8_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_8_grad/Shape" + input: "compute_loss/strided_slice_8/stack" + input: "compute_loss/strided_slice_8/stack_1" + input: "compute_loss/strided_slice_8/stack_2" + input: "train_op/gradients/compute_loss/sub_4_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_9_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\177\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_9_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_9_grad/Shape" + input: "compute_loss/strided_slice_9/stack" + input: "compute_loss/strided_slice_9/stack_1" + input: "compute_loss/strided_slice_9/stack_2" + input: "train_op/gradients/compute_loss/sub_4_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_11_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_6_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 206 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_11_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_6_grad/mul" + input: "^train_op/gradients/compute_loss/sub_11_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_11_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_6_grad/mul" + input: "^train_op/gradients/compute_loss/sub_11_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_6_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 206 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_11_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_11_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_11_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_11_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 206 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_10_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_7_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_10_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_7_grad/mul" + input: "^train_op/gradients/compute_loss/sub_10_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_10_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_7_grad/mul" + input: "^train_op/gradients/compute_loss/sub_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_7_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_10_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_10_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_10_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_30_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000?\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_30_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_30_grad/Shape" + input: "compute_loss/strided_slice_30/stack" + input: "compute_loss/strided_slice_30/stack_1" + input: "compute_loss/strided_slice_30/stack_2" + input: "train_op/gradients/compute_loss/sub_13_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_31_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000?\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_31_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_31_grad/Shape" + input: "compute_loss/strided_slice_31/stack" + input: "compute_loss/strided_slice_31/stack_1" + input: "compute_loss/strided_slice_31/stack_2" + input: "train_op/gradients/compute_loss/sub_13_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_46_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000g\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_46_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_46_grad/Shape" + input: "compute_loss/strided_slice_46/stack" + input: "compute_loss/strided_slice_46/stack_1" + input: "compute_loss/strided_slice_46/stack_2" + input: "train_op/gradients/compute_loss/sub_19_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_47_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000g\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_47_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_47_grad/Shape" + input: "compute_loss/strided_slice_47/stack" + input: "compute_loss/strided_slice_47/stack_1" + input: "compute_loss/strided_slice_47/stack_2" + input: "train_op/gradients/compute_loss/sub_19_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_44_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000g\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_44_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_44_grad/Shape" + input: "compute_loss/strided_slice_44/stack" + input: "compute_loss/strided_slice_44/stack_1" + input: "compute_loss/strided_slice_44/stack_2" + input: "train_op/gradients/compute_loss/sub_18_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_45_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000g\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_45_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_45_grad/Shape" + input: "compute_loss/strided_slice_45/stack" + input: "compute_loss/strided_slice_45/stack_1" + input: "compute_loss/strided_slice_45/stack_2" + input: "train_op/gradients/compute_loss/sub_18_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/AddN_13" + op: "AddN" + input: "train_op/gradients/compute_loss/strided_slice_48_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_49_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_50_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_51_grad/StridedSliceGrad" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_48_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_16_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_13" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_16_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_13" + input: "^train_op/gradients/compute_loss/sub_16_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_16_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_13" + input: "^train_op/gradients/compute_loss/sub_16_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_48_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_16_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_16_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_16_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_16_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 31 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_14" + op: "AddN" + input: "train_op/gradients/compute_loss/strided_slice_66_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_67_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_64_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_65_grad/StridedSliceGrad" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_66_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_25_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_14" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_25_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_14" + input: "^train_op/gradients/compute_loss/sub_25_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_25_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_14" + input: "^train_op/gradients/compute_loss/sub_25_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_66_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_25_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_25_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_25_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_25_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 51 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_60_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_60_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_60_grad/Shape" + input: "compute_loss/strided_slice_60/stack" + input: "compute_loss/strided_slice_60/stack_1" + input: "compute_loss/strided_slice_60/stack_2" + input: "train_op/gradients/compute_loss/sub_24_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_61_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_61_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_61_grad/Shape" + input: "compute_loss/strided_slice_61/stack" + input: "compute_loss/strided_slice_61/stack_1" + input: "compute_loss/strided_slice_61/stack_2" + input: "train_op/gradients/compute_loss/sub_24_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_6_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_4_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_6_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_4_grad/mul" + input: "^train_op/gradients/compute_loss/sub_6_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_6_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_4_grad/mul" + input: "^train_op/gradients/compute_loss/sub_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_4_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_6_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_6_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_6_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/AddN_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/sub_7_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/AddN_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_7_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_1/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_5_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/AddN_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_7_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_1/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_5_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/AddN_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_7_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_1/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_5_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/AddN_grad/tuple/control_dependency_3" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_7_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling_1/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_5_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_2/AddN_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_2/Reshape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_2/mul_3" + input: "train_op/gradients/compute_loss/image_sampling_2/AddN_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_2/AddN_grad/tuple/control_dependency_1" + input: "compute_loss/image_sampling_2/Reshape_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_2/mul_4" + input: "train_op/gradients/compute_loss/image_sampling_2/AddN_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_2/AddN_grad/tuple/control_dependency_2" + input: "compute_loss/image_sampling_2/Reshape_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_2/mul_5" + input: "train_op/gradients/compute_loss/image_sampling_2/AddN_grad/tuple/control_dependency_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_2/AddN_grad/tuple/control_dependency_3" + input: "compute_loss/image_sampling_2/Reshape_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_2/mul_6" + input: "train_op/gradients/compute_loss/image_sampling_2/AddN_grad/tuple/control_dependency_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_3_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_3/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_3_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_7_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_3/sub_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_3_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_3_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_3_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_3_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_4_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_3/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_4_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_8_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_3/sub_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_4_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_4_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_4_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_4_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_4_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_5_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_3/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_5_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_9_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_3/sub_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_5_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_5_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_5_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_5_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_5_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_6_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_3/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_6_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_10_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_3/sub_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_6_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_6_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_6_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_6_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_6_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_6_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/mul_6_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_6_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_3/mul_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_6_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_15" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_4_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/sub_2_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_15" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/sub_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_15" + input: "^train_op/gradients/compute_loss/image_sampling_4/sub_2_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/sub_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_15" + input: "^train_op/gradients/compute_loss/image_sampling_4/sub_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/sub_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/sub_2_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_4/sub_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/sub_2_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_16" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_5_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/sub_4_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_16" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/sub_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_16" + input: "^train_op/gradients/compute_loss/image_sampling_4/sub_4_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/sub_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_16" + input: "^train_op/gradients/compute_loss/image_sampling_4/sub_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/sub_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/sub_4_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_4/sub_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/sub_4_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_17" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_5_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_6_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/sub_3_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_17" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/sub_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_17" + input: "^train_op/gradients/compute_loss/image_sampling_4/sub_3_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/sub_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_17" + input: "^train_op/gradients/compute_loss/image_sampling_4/sub_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/sub_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/sub_3_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_4/sub_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/sub_3_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_18" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_4_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_4/mul_6_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/sub_5_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_18" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/sub_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_18" + input: "^train_op/gradients/compute_loss/image_sampling_4/sub_5_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/sub_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_18" + input: "^train_op/gradients/compute_loss/image_sampling_4/sub_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/sub_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/sub_5_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_4/sub_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/sub_5_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_5/clip_by_value_2/Minimum" + input: "compute_loss/image_sampling_5/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_5/sub_2_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_5/sub_2_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_5/clip_by_value_3/Minimum" + input: "compute_loss/image_sampling_5/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_5/sub_4_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_5/sub_4_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_5/clip_by_value/Minimum" + input: "compute_loss/image_sampling_5/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_5/sub_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_5/sub_3_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_5/clip_by_value_1/Minimum" + input: "compute_loss/image_sampling_5/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_5/sub_5_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_5/sub_5_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_6/add" + input: "compute_loss/image_sampling_6/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_6/add_1" + input: "compute_loss/image_sampling_6/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_6/Floor" + input: "compute_loss/image_sampling_6/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_6/Floor_1" + input: "compute_loss/image_sampling_6/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_7/add_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_7/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_7/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/add_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/add_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_2/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_7/add_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/add_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_7/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_7/add_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/add_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/add_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/add_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/add_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/add_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_3/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_7/add_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/add_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_7/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/add_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_7/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/add_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_3_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 414 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_grad/mul" + input: "^train_op/gradients/compute_loss/sub_3_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_grad/mul" + input: "^train_op/gradients/compute_loss/sub_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 414 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_3_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_3_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 414 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_2_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/Abs_1_grad/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/Abs_1_grad/mul" + input: "^train_op/gradients/compute_loss/sub_2_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/Abs_1_grad/mul" + input: "^train_op/gradients/compute_loss/sub_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_1_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_2_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_2_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_10_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\177\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_10_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_10_grad/Shape" + input: "compute_loss/strided_slice_10/stack" + input: "compute_loss/strided_slice_10/stack_1" + input: "compute_loss/strided_slice_10/stack_2" + input: "train_op/gradients/compute_loss/sub_5_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_11_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\177\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_11_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_11_grad/Shape" + input: "compute_loss/strided_slice_11/stack" + input: "compute_loss/strided_slice_11/stack_1" + input: "compute_loss/strided_slice_11/stack_2" + input: "train_op/gradients/compute_loss/sub_5_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_26_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\317\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_26_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_26_grad/Shape" + input: "compute_loss/strided_slice_26/stack" + input: "compute_loss/strided_slice_26/stack_1" + input: "compute_loss/strided_slice_26/stack_2" + input: "train_op/gradients/compute_loss/sub_11_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_27_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\317\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_27_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_27_grad/Shape" + input: "compute_loss/strided_slice_27/stack" + input: "compute_loss/strided_slice_27/stack_1" + input: "compute_loss/strided_slice_27/stack_2" + input: "train_op/gradients/compute_loss/sub_11_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_24_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\317\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_24_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_24_grad/Shape" + input: "compute_loss/strided_slice_24/stack" + input: "compute_loss/strided_slice_24/stack_1" + input: "compute_loss/strided_slice_24/stack_2" + input: "train_op/gradients/compute_loss/sub_10_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_25_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\317\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_25_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_25_grad/Shape" + input: "compute_loss/strided_slice_25/stack" + input: "compute_loss/strided_slice_25/stack_1" + input: "compute_loss/strided_slice_25/stack_2" + input: "train_op/gradients/compute_loss/sub_10_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/AddN_19" + op: "AddN" + input: "train_op/gradients/compute_loss/strided_slice_28_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_29_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_30_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_31_grad/StridedSliceGrad" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_28_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_8_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_19" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_8_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_19" + input: "^train_op/gradients/compute_loss/sub_8_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_8_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_19" + input: "^train_op/gradients/compute_loss/sub_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_28_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_8_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_8_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_8_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 63 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_20" + op: "AddN" + input: "train_op/gradients/compute_loss/strided_slice_46_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_47_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_44_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_45_grad/StridedSliceGrad" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_46_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_17_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_20" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_17_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_20" + input: "^train_op/gradients/compute_loss/sub_17_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_17_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_20" + input: "^train_op/gradients/compute_loss/sub_17_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_46_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_17_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_17_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_17_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_17_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 103 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_40_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_40_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_40_grad/Shape" + input: "compute_loss/strided_slice_40/stack" + input: "compute_loss/strided_slice_40/stack_1" + input: "compute_loss/strided_slice_40/stack_2" + input: "train_op/gradients/compute_loss/sub_16_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_41_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_41_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_41_grad/Shape" + input: "compute_loss/strided_slice_41/stack" + input: "compute_loss/strided_slice_41/stack_1" + input: "compute_loss/strided_slice_41/stack_2" + input: "train_op/gradients/compute_loss/sub_16_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_62_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_62_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_62_grad/Shape" + input: "compute_loss/strided_slice_62/stack" + input: "compute_loss/strided_slice_62/stack_1" + input: "compute_loss/strided_slice_62/stack_2" + input: "train_op/gradients/compute_loss/sub_25_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_63_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_63_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_63_grad/Shape" + input: "compute_loss/strided_slice_63/stack" + input: "compute_loss/strided_slice_63/stack_1" + input: "compute_loss/strided_slice_63/stack_2" + input: "train_op/gradients/compute_loss/sub_25_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/AddN_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/sub_6_grad/tuple/control_dependency" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/AddN_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_6_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_4_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/AddN_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_6_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_4_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/AddN_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_6_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_4_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/AddN_grad/tuple/control_dependency_3" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_6_grad/tuple/control_dependency" + input: "^train_op/gradients/compute_loss/image_sampling/AddN_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Abs_4_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_1/AddN_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_1/Reshape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_1/mul_3" + input: "train_op/gradients/compute_loss/image_sampling_1/AddN_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_1/AddN_grad/tuple/control_dependency_1" + input: "compute_loss/image_sampling_1/Reshape_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_1/mul_4" + input: "train_op/gradients/compute_loss/image_sampling_1/AddN_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_1/AddN_grad/tuple/control_dependency_2" + input: "compute_loss/image_sampling_1/Reshape_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_1/mul_5" + input: "train_op/gradients/compute_loss/image_sampling_1/AddN_grad/tuple/control_dependency_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_1/AddN_grad/tuple/control_dependency_3" + input: "compute_loss/image_sampling_1/Reshape_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling_1/mul_6" + input: "train_op/gradients/compute_loss/image_sampling_1/AddN_grad/tuple/control_dependency_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_3_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_2/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_3_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_7_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_2/sub_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_3_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_3_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_3_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_3_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_4_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_2/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_4_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_8_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_2/sub_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_4_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_4_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_4_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_4_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_4_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_5_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_2/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_5_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_9_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_2/sub_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_5_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_5_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_5_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_5_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_5_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_6_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_2/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_6_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_10_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_2/sub_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_6_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_6_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_6_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_6_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_6_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_6_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/mul_6_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_6_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_2/mul_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_6_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_21" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_4_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/sub_2_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_21" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/sub_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_21" + input: "^train_op/gradients/compute_loss/image_sampling_3/sub_2_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/sub_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_21" + input: "^train_op/gradients/compute_loss/image_sampling_3/sub_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/sub_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/sub_2_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_3/sub_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/sub_2_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_22" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_5_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/sub_4_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_22" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/sub_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_22" + input: "^train_op/gradients/compute_loss/image_sampling_3/sub_4_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/sub_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_22" + input: "^train_op/gradients/compute_loss/image_sampling_3/sub_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/sub_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/sub_4_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_3/sub_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/sub_4_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_23" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_5_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_6_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/sub_3_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_23" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/sub_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_23" + input: "^train_op/gradients/compute_loss/image_sampling_3/sub_3_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/sub_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_23" + input: "^train_op/gradients/compute_loss/image_sampling_3/sub_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/sub_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/sub_3_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_3/sub_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/sub_3_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_24" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_4_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_3/mul_6_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/sub_5_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_24" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/sub_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_24" + input: "^train_op/gradients/compute_loss/image_sampling_3/sub_5_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/sub_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_24" + input: "^train_op/gradients/compute_loss/image_sampling_3/sub_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/sub_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/sub_5_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_3/sub_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/sub_5_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_4/clip_by_value_2/Minimum" + input: "compute_loss/image_sampling_4/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_4/sub_2_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_4/sub_2_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_4/clip_by_value_3/Minimum" + input: "compute_loss/image_sampling_4/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_4/sub_4_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_4/sub_4_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_4/clip_by_value/Minimum" + input: "compute_loss/image_sampling_4/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_4/sub_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_4/sub_3_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_4/clip_by_value_1/Minimum" + input: "compute_loss/image_sampling_4/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_4/sub_5_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_4/sub_5_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_5/add" + input: "compute_loss/image_sampling_5/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_5/add_1" + input: "compute_loss/image_sampling_5/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_5/Floor" + input: "compute_loss/image_sampling_5/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_5/Floor_1" + input: "compute_loss/image_sampling_5/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_6/add_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_6/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_6/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/add_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/add_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_2/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_6/add_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/add_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_6/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_6/add_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/add_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/add_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/add_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/add_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_6/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/add_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_3/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_6/add_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/add_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_6/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/add_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_6/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/add_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/AddN_25" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_7/add_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/clip_by_value/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_26" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_7/add_1_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/clip_by_value_1/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_6_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\237\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_6_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_6_grad/Shape" + input: "compute_loss/strided_slice_6/stack" + input: "compute_loss/strided_slice_6/stack_1" + input: "compute_loss/strided_slice_6/stack_2" + input: "train_op/gradients/compute_loss/sub_3_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_7_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\237\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_7_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_7_grad/Shape" + input: "compute_loss/strided_slice_7/stack" + input: "compute_loss/strided_slice_7/stack_1" + input: "compute_loss/strided_slice_7/stack_2" + input: "train_op/gradients/compute_loss/sub_3_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_4_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\237\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_4_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_4_grad/Shape" + input: "compute_loss/strided_slice_4/stack" + input: "compute_loss/strided_slice_4/stack_1" + input: "compute_loss/strided_slice_4/stack_2" + input: "train_op/gradients/compute_loss/sub_2_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_5_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\237\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_5_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_5_grad/Shape" + input: "compute_loss/strided_slice_5/stack" + input: "compute_loss/strided_slice_5/stack_1" + input: "compute_loss/strided_slice_5/stack_2" + input: "train_op/gradients/compute_loss/sub_2_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/AddN_27" + op: "AddN" + input: "train_op/gradients/compute_loss/strided_slice_8_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_9_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_10_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_11_grad/StridedSliceGrad" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_8_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_27" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_27" + input: "^train_op/gradients/compute_loss/sub_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_27" + input: "^train_op/gradients/compute_loss/sub_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_8_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 127 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_28" + op: "AddN" + input: "train_op/gradients/compute_loss/strided_slice_26_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_27_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_24_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_25_grad/StridedSliceGrad" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_26_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_9_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_28" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_9_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_28" + input: "^train_op/gradients/compute_loss/sub_9_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_9_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_28" + input: "^train_op/gradients/compute_loss/sub_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_26_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_9_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_9_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_9_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 207 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_20_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_20_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_20_grad/Shape" + input: "compute_loss/strided_slice_20/stack" + input: "compute_loss/strided_slice_20/stack_1" + input: "compute_loss/strided_slice_20/stack_2" + input: "train_op/gradients/compute_loss/sub_8_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_21_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_21_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_21_grad/Shape" + input: "compute_loss/strided_slice_21/stack" + input: "compute_loss/strided_slice_21/stack_1" + input: "compute_loss/strided_slice_21/stack_2" + input: "train_op/gradients/compute_loss/sub_8_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_42_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_42_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_42_grad/Shape" + input: "compute_loss/strided_slice_42/stack" + input: "compute_loss/strided_slice_42/stack_1" + input: "compute_loss/strided_slice_42/stack_2" + input: "train_op/gradients/compute_loss/sub_17_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_43_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_43_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_43_grad/Shape" + input: "compute_loss/strided_slice_43/stack" + input: "compute_loss/strided_slice_43/stack_1" + input: "compute_loss/strided_slice_43/stack_2" + input: "train_op/gradients/compute_loss/sub_17_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling/AddN_grad/tuple/control_dependency" + input: "compute_loss/image_sampling/Reshape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling/mul_3" + input: "train_op/gradients/compute_loss/image_sampling/AddN_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling/mul_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/mul_7_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/mul_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_7_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling/mul_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_7_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling/AddN_grad/tuple/control_dependency_1" + input: "compute_loss/image_sampling/Reshape_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling/mul_4" + input: "train_op/gradients/compute_loss/image_sampling/AddN_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling/mul_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/mul_8_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/mul_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_8_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling/mul_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_8_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling/AddN_grad/tuple/control_dependency_2" + input: "compute_loss/image_sampling/Reshape_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling/mul_5" + input: "train_op/gradients/compute_loss/image_sampling/AddN_grad/tuple/control_dependency_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling/mul_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/mul_9_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/mul_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_9_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling/mul_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_9_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling/AddN_grad/tuple/control_dependency_3" + input: "compute_loss/image_sampling/Reshape_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/Mul" + input: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/Mul_1" + op: "Mul" + input: "compute_loss/image_sampling/mul_6" + input: "train_op/gradients/compute_loss/image_sampling/AddN_grad/tuple/control_dependency_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/Mul_1" + input: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling/mul_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/mul_10_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/mul_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_10_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling/mul_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_10_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_3_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_1/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_3_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_7_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_1/sub_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_3_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_3_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_3_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_3_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_4_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_1/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_4_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_8_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_1/sub_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_4_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_4_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_4_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_4_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_4_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_5_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_1/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_5_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_9_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_1/sub_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_5_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_5_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_5_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_5_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_5_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_6_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_1/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_6_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_10_grad/tuple/control_dependency" + input: "compute_loss/image_sampling_1/sub_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_6_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_6_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_6_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_6_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_6_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_6_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/mul_6_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_6_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling_1/mul_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_6_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_29" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_4_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/sub_2_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_29" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/sub_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_29" + input: "^train_op/gradients/compute_loss/image_sampling_2/sub_2_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/sub_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_29" + input: "^train_op/gradients/compute_loss/image_sampling_2/sub_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/sub_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/sub_2_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_2/sub_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/sub_2_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_30" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_5_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/sub_4_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_30" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/sub_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_30" + input: "^train_op/gradients/compute_loss/image_sampling_2/sub_4_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/sub_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_30" + input: "^train_op/gradients/compute_loss/image_sampling_2/sub_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/sub_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/sub_4_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_2/sub_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/sub_4_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_31" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_5_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_6_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/sub_3_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_31" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/sub_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_31" + input: "^train_op/gradients/compute_loss/image_sampling_2/sub_3_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/sub_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_31" + input: "^train_op/gradients/compute_loss/image_sampling_2/sub_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/sub_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/sub_3_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_2/sub_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/sub_3_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_32" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_4_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_2/mul_6_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/sub_5_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_32" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/sub_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_32" + input: "^train_op/gradients/compute_loss/image_sampling_2/sub_5_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/sub_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_32" + input: "^train_op/gradients/compute_loss/image_sampling_2/sub_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/sub_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/sub_5_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_2/sub_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/sub_5_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_3/clip_by_value_2/Minimum" + input: "compute_loss/image_sampling_3/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_3/sub_2_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_3/sub_2_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_3/clip_by_value_3/Minimum" + input: "compute_loss/image_sampling_3/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_3/sub_4_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_3/sub_4_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_3/clip_by_value/Minimum" + input: "compute_loss/image_sampling_3/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_3/sub_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_3/sub_3_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_3/clip_by_value_1/Minimum" + input: "compute_loss/image_sampling_3/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_3/sub_5_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_3/sub_5_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_4/add" + input: "compute_loss/image_sampling_4/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_4/add_1" + input: "compute_loss/image_sampling_4/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_4/Floor" + input: "compute_loss/image_sampling_4/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_4/Floor_1" + input: "compute_loss/image_sampling_4/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_5/add_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_5/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_5/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/add_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/add_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_2/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_5/add_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/add_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_5/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_5/add_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/add_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/add_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/add_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/add_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_5/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/add_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_3/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_5/add_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/add_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_5/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/add_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_5/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/add_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/AddN_33" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_6/add_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/clip_by_value/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_34" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_6/add_1_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/clip_by_value_1/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_35" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_7/sub_2_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_7/sub_3_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/sub_2_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_36" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_7/sub_4_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_7/sub_5_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_7/sub_4_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_7/split_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/AddN_35" + input: "train_op/gradients/AddN_36" + input: "compute_loss/image_sampling_7/split/split_dim" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_37" + op: "AddN" + input: "train_op/gradients/compute_loss/strided_slice_6_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_7_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_4_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_5_grad/StridedSliceGrad" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_6_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_1_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_37" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_37" + input: "^train_op/gradients/compute_loss/sub_1_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/sub_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_37" + input: "^train_op/gradients/compute_loss/sub_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_6_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/sub_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/sub_1_grad/Neg" + input: "^train_op/gradients/compute_loss/sub_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/sub_1_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 415 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_grad/Shape" + input: "compute_loss/strided_slice/stack" + input: "compute_loss/strided_slice/stack_1" + input: "compute_loss/strided_slice/stack_2" + input: "train_op/gradients/compute_loss/sub_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 13 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_1_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_1_grad/Shape" + input: "compute_loss/strided_slice_1/stack" + input: "compute_loss/strided_slice_1/stack_1" + input: "compute_loss/strided_slice_1/stack_2" + input: "train_op/gradients/compute_loss/sub_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 13 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_22_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_22_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_22_grad/Shape" + input: "compute_loss/strided_slice_22/stack" + input: "compute_loss/strided_slice_22/stack_1" + input: "compute_loss/strided_slice_22/stack_2" + input: "train_op/gradients/compute_loss/sub_9_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_23_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_23_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_23_grad/Shape" + input: "compute_loss/strided_slice_23/stack" + input: "compute_loss/strided_slice_23/stack_1" + input: "compute_loss/strided_slice_23/stack_2" + input: "train_op/gradients/compute_loss/sub_9_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_3_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/tuple/control_dependency" + input: "compute_loss/image_sampling/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_3_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling/mul_7_grad/tuple/control_dependency" + input: "compute_loss/image_sampling/sub_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling/mul_3_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling/mul_3_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/mul_3_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling/mul_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/mul_3_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling/mul_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_4_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/tuple/control_dependency" + input: "compute_loss/image_sampling/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_4_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling/mul_8_grad/tuple/control_dependency" + input: "compute_loss/image_sampling/sub_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling/mul_4_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling/mul_4_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/mul_4_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling/mul_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_4_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/mul_4_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling/mul_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_5_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/tuple/control_dependency" + input: "compute_loss/image_sampling/sub_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_5_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling/mul_9_grad/tuple/control_dependency" + input: "compute_loss/image_sampling/sub_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling/mul_5_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling/mul_5_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/mul_5_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling/mul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/mul_5_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling/mul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_5_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_6_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/tuple/control_dependency" + input: "compute_loss/image_sampling/sub_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_6_grad/Mul_1" + op: "Mul" + input: "train_op/gradients/compute_loss/image_sampling/mul_10_grad/tuple/control_dependency" + input: "compute_loss/image_sampling/sub_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_6_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling/mul_6_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling/mul_6_grad/Mul_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_6_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/mul_6_grad/Mul" + input: "^train_op/gradients/compute_loss/image_sampling/mul_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_6_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/mul_6_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/mul_6_grad/Mul_1" + input: "^train_op/gradients/compute_loss/image_sampling/mul_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_6_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_38" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_4_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/sub_2_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_38" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/sub_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_38" + input: "^train_op/gradients/compute_loss/image_sampling_1/sub_2_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/sub_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_38" + input: "^train_op/gradients/compute_loss/image_sampling_1/sub_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/sub_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/sub_2_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_1/sub_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/sub_2_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_39" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_5_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/sub_4_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_39" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/sub_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_39" + input: "^train_op/gradients/compute_loss/image_sampling_1/sub_4_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/sub_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_39" + input: "^train_op/gradients/compute_loss/image_sampling_1/sub_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/sub_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/sub_4_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_1/sub_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/sub_4_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_40" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_5_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_6_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/sub_3_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_40" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/sub_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_40" + input: "^train_op/gradients/compute_loss/image_sampling_1/sub_3_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/sub_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_40" + input: "^train_op/gradients/compute_loss/image_sampling_1/sub_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/sub_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/sub_3_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_1/sub_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/sub_3_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_41" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_4_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_1/mul_6_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/sub_5_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_41" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/sub_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_41" + input: "^train_op/gradients/compute_loss/image_sampling_1/sub_5_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/sub_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_41" + input: "^train_op/gradients/compute_loss/image_sampling_1/sub_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/sub_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/sub_5_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling_1/sub_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/sub_5_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_2/clip_by_value_2/Minimum" + input: "compute_loss/image_sampling_2/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_2/sub_2_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_2/sub_2_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_2/clip_by_value_3/Minimum" + input: "compute_loss/image_sampling_2/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_2/sub_4_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_2/sub_4_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_2/clip_by_value/Minimum" + input: "compute_loss/image_sampling_2/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_2/sub_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_2/sub_3_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_2/clip_by_value_1/Minimum" + input: "compute_loss/image_sampling_2/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_2/sub_5_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_2/sub_5_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_3/add" + input: "compute_loss/image_sampling_3/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_3/add_1" + input: "compute_loss/image_sampling_3/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_3/Floor" + input: "compute_loss/image_sampling_3/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_3/Floor_1" + input: "compute_loss/image_sampling_3/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_4/add_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_4/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_4/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/add_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/add_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_2/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_4/add_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/add_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_4/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_4/add_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/add_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/add_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/add_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/add_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_4/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/add_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_3/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_4/add_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/add_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_4/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/add_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_4/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/add_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/AddN_42" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_5/add_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/clip_by_value/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_43" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_5/add_1_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/clip_by_value_1/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_44" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_6/sub_2_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_6/sub_3_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/sub_2_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_45" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_6/sub_4_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_6/sub_5_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_6/sub_4_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_6/split_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/AddN_44" + input: "train_op/gradients/AddN_45" + input: "compute_loss/image_sampling_6/split/split_dim" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/transpose_15_grad/InvertPermutation" + op: "InvertPermutation" + input: "compute_loss/transpose_15/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/transpose_15_grad/transpose" + op: "Transpose" + input: "train_op/gradients/compute_loss/image_sampling_7/split_grad/concat" + input: "train_op/gradients/compute_loss/transpose_15_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_2_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_2_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_2_grad/Shape" + input: "compute_loss/strided_slice_2/stack" + input: "compute_loss/strided_slice_2/stack_1" + input: "compute_loss/strided_slice_2/stack_2" + input: "train_op/gradients/compute_loss/sub_1_grad/tuple/control_dependency" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 11 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 15 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_3_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_3_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_3_grad/Shape" + input: "compute_loss/strided_slice_3/stack" + input: "compute_loss/strided_slice_3/stack_1" + input: "compute_loss/strided_slice_3/stack_2" + input: "train_op/gradients/compute_loss/sub_1_grad/tuple/control_dependency_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 15 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 11 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "train_op/gradients/AddN_46" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling/mul_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling/mul_4_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/sub_2_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_46" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/sub_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_46" + input: "^train_op/gradients/compute_loss/image_sampling/sub_2_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/sub_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_46" + input: "^train_op/gradients/compute_loss/image_sampling/sub_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_3_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/sub_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/sub_2_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling/sub_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/sub_2_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_47" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling/mul_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling/mul_5_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/sub_4_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_47" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/sub_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_47" + input: "^train_op/gradients/compute_loss/image_sampling/sub_4_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/sub_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_47" + input: "^train_op/gradients/compute_loss/image_sampling/sub_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_3_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/sub_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/sub_4_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling/sub_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/sub_4_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_48" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling/mul_5_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling/mul_6_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/sub_3_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_48" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/sub_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_48" + input: "^train_op/gradients/compute_loss/image_sampling/sub_3_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/sub_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_48" + input: "^train_op/gradients/compute_loss/image_sampling/sub_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_5_grad/Mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/sub_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/sub_3_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling/sub_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/sub_3_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_49" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling/mul_4_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling/mul_6_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/sub_5_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_49" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/sub_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/AddN_49" + input: "^train_op/gradients/compute_loss/image_sampling/sub_5_grad/Neg" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/sub_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/AddN_49" + input: "^train_op/gradients/compute_loss/image_sampling/sub_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/mul_4_grad/Mul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/sub_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/sub_5_grad/Neg" + input: "^train_op/gradients/compute_loss/image_sampling/sub_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/sub_5_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_1/clip_by_value_2/Minimum" + input: "compute_loss/image_sampling_1/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_1/sub_2_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_1/sub_2_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_1/clip_by_value_3/Minimum" + input: "compute_loss/image_sampling_1/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_1/sub_4_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_1/sub_4_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_1/clip_by_value/Minimum" + input: "compute_loss/image_sampling_1/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_1/sub_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_1/sub_3_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling_1/clip_by_value_1/Minimum" + input: "compute_loss/image_sampling_1/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_1/sub_5_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_1/sub_5_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_2/add" + input: "compute_loss/image_sampling_2/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_2/add_1" + input: "compute_loss/image_sampling_2/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_2/Floor" + input: "compute_loss/image_sampling_2/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_2/Floor_1" + input: "compute_loss/image_sampling_2/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_3/add_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_3/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_3/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/add_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/add_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_2/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_3/add_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/add_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_3/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_3/add_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/add_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/add_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/add_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/add_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_3/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/add_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_3/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_3/add_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/add_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_3/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/add_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_3/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/add_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/AddN_50" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_4/add_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/clip_by_value/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_51" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_4/add_1_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/clip_by_value_1/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_52" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_5/sub_2_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_5/sub_3_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/sub_2_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_53" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_5/sub_4_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_5/sub_5_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_5/sub_4_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_5/split_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/AddN_52" + input: "train_op/gradients/AddN_53" + input: "compute_loss/image_sampling_5/split/split_dim" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/transpose_13_grad/InvertPermutation" + op: "InvertPermutation" + input: "compute_loss/transpose_13/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/transpose_13_grad/transpose" + op: "Transpose" + input: "train_op/gradients/compute_loss/image_sampling_6/split_grad/concat" + input: "train_op/gradients/compute_loss/transpose_13_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_39_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\002\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_39_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/transpose_15_grad/transpose" + input: "train_op/gradients/compute_loss/Reshape_39_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling/clip_by_value_2/Minimum" + input: "compute_loss/image_sampling/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling/sub_2_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling/sub_2_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling/clip_by_value_3/Minimum" + input: "compute_loss/image_sampling/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling/sub_4_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling/sub_4_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling/clip_by_value/Minimum" + input: "compute_loss/image_sampling/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling/sub_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling/sub_3_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/image_sampling/clip_by_value_1/Minimum" + input: "compute_loss/image_sampling/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling/sub_5_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling/sub_5_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_1/add" + input: "compute_loss/image_sampling_1/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_1/add_1" + input: "compute_loss/image_sampling_1/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_1/Floor" + input: "compute_loss/image_sampling_1/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling_1/Floor_1" + input: "compute_loss/image_sampling_1/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_2/add_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_2/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_2/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/add_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/add_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_2/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_2/add_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/add_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_2/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_2/add_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/add_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/add_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/add_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/add_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_2/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/add_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_3/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_2/add_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/add_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_2/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/add_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_2/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/add_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/AddN_54" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_3/add_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/clip_by_value/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_55" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_3/add_1_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/clip_by_value_1/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_56" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_4/sub_2_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_4/sub_3_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/sub_2_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_57" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_4/sub_4_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_4/sub_5_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_4/sub_4_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_4/split_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/AddN_56" + input: "train_op/gradients/AddN_57" + input: "compute_loss/image_sampling_4/split/split_dim" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/transpose_11_grad/InvertPermutation" + op: "InvertPermutation" + input: "compute_loss/transpose_11/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/transpose_11_grad/transpose" + op: "Transpose" + input: "train_op/gradients/compute_loss/image_sampling_5/split_grad/concat" + input: "train_op/gradients/compute_loss/transpose_11_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_34_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\002\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_34_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/transpose_13_grad/transpose" + input: "train_op/gradients/compute_loss/Reshape_34_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_149_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_149_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_149/axis" + input: "train_op/gradients/compute_loss/concat_149_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_149_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_149_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_149_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_149_grad/mod" + input: "train_op/gradients/compute_loss/concat_149_grad/Shape" + input: "train_op/gradients/compute_loss/concat_149_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_149_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_39_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_149_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_149_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_149_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_39_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_149_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_149_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_149_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_149_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_149_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_149_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_149_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_149_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_149_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_149_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_149_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_149_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_149_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling/add" + input: "compute_loss/image_sampling/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling/add_1" + input: "compute_loss/image_sampling/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling/Floor" + input: "compute_loss/image_sampling/Cast_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/image_sampling/Floor_1" + input: "compute_loss/image_sampling/Cast_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_1/add_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/add_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_2/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_1/add_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/add_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_1/add_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/add_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/add_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/add_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/add_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_1/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/add_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_3/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling_1/add_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/add_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling_1/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/add_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling_1/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/add_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/AddN_58" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_2/add_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/clip_by_value/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_59" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_2/add_1_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/clip_by_value_1/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_60" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_3/sub_2_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_3/sub_3_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/sub_2_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_61" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_3/sub_4_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_3/sub_5_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_3/sub_4_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_3/split_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/AddN_60" + input: "train_op/gradients/AddN_61" + input: "compute_loss/image_sampling_3/split/split_dim" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/transpose_9_grad/InvertPermutation" + op: "InvertPermutation" + input: "compute_loss/transpose_9/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/transpose_9_grad/transpose" + op: "Transpose" + input: "train_op/gradients/compute_loss/image_sampling_4/split_grad/concat" + input: "train_op/gradients/compute_loss/transpose_9_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_29_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_29_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/transpose_11_grad/transpose" + input: "train_op/gradients/compute_loss/Reshape_29_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_131_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_131_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_131/axis" + input: "train_op/gradients/compute_loss/concat_131_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_131_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_131_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_131_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_131_grad/mod" + input: "train_op/gradients/compute_loss/concat_131_grad/Shape" + input: "train_op/gradients/compute_loss/concat_131_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_131_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_34_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_131_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_131_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_131_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_34_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_131_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_131_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_131_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_131_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_131_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_131_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_131_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_131_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_131_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_131_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_131_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_131_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_131_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_14_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_14_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_14_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/truediv_14_grad/Shape" + input: "train_op/gradients/compute_loss/truediv_14_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_14_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/concat_149_grad/tuple/control_dependency" + input: "compute_loss/add_53" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_14_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_14_grad/RealDiv" + input: "train_op/gradients/compute_loss/truediv_14_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_14_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_14_grad/Sum" + input: "train_op/gradients/compute_loss/truediv_14_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_14_grad/Neg" + op: "Neg" + input: "compute_loss/Slice_53" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_14_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_14_grad/Neg" + input: "compute_loss/add_53" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_14_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_14_grad/RealDiv_1" + input: "compute_loss/add_53" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_14_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_149_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/truediv_14_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_14_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_14_grad/mul" + input: "train_op/gradients/compute_loss/truediv_14_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_14_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_14_grad/Sum_1" + input: "train_op/gradients/compute_loss/truediv_14_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_14_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/truediv_14_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_14_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/truediv_14_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_14_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_14_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_14_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_14_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_14_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/truediv_14_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_14_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_15_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_15_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_15_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/truediv_15_grad/Shape" + input: "train_op/gradients/compute_loss/truediv_15_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_15_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/concat_149_grad/tuple/control_dependency_1" + input: "compute_loss/add_54" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_15_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_15_grad/RealDiv" + input: "train_op/gradients/compute_loss/truediv_15_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_15_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_15_grad/Sum" + input: "train_op/gradients/compute_loss/truediv_15_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_15_grad/Neg" + op: "Neg" + input: "compute_loss/Slice_54" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_15_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_15_grad/Neg" + input: "compute_loss/add_54" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_15_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_15_grad/RealDiv_1" + input: "compute_loss/add_54" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_15_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_149_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/truediv_15_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_15_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_15_grad/mul" + input: "train_op/gradients/compute_loss/truediv_15_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_15_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_15_grad/Sum_1" + input: "train_op/gradients/compute_loss/truediv_15_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_15_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/truediv_15_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_15_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/truediv_15_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_15_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_15_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_15_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_15_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_15_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/truediv_15_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_15_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling/add_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/add_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling/add_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_2/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling/add_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/add_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling/add_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/add_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/add_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/add_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/add_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/add_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/image_sampling/add_1_grad/Shape" + input: "train_op/gradients/compute_loss/image_sampling/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/add_1_grad/Sum" + input: "train_op/gradients/compute_loss/image_sampling/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_3/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling/add_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/image_sampling/add_1_grad/Sum_1" + input: "train_op/gradients/compute_loss/image_sampling/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/image_sampling/add_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/add_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/add_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/image_sampling/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/add_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/add_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/image_sampling/add_1_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/image_sampling/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/add_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/AddN_62" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_1/add_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/clip_by_value/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_63" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling_1/add_1_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/clip_by_value_1/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_64" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_2/sub_2_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_2/sub_3_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/sub_2_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_65" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_2/sub_4_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_2/sub_5_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_2/sub_4_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_2/split_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/AddN_64" + input: "train_op/gradients/AddN_65" + input: "compute_loss/image_sampling_2/split/split_dim" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/transpose_7_grad/InvertPermutation" + op: "InvertPermutation" + input: "compute_loss/transpose_7/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/transpose_7_grad/transpose" + op: "Transpose" + input: "train_op/gradients/compute_loss/image_sampling_3/split_grad/concat" + input: "train_op/gradients/compute_loss/transpose_7_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_24_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_24_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/transpose_9_grad/transpose" + input: "train_op/gradients/compute_loss/Reshape_24_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_111_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_111_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_111/axis" + input: "train_op/gradients/compute_loss/concat_111_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_111_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_111_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_111_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_111_grad/mod" + input: "train_op/gradients/compute_loss/concat_111_grad/Shape" + input: "train_op/gradients/compute_loss/concat_111_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_111_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_29_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_111_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_111_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_111_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_29_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_111_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_111_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_111_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_111_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_111_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_111_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_111_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_111_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_111_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_111_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_111_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_111_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_111_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_12_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_12_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_12_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/truediv_12_grad/Shape" + input: "train_op/gradients/compute_loss/truediv_12_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_12_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/concat_131_grad/tuple/control_dependency" + input: "compute_loss/add_48" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_12_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_12_grad/RealDiv" + input: "train_op/gradients/compute_loss/truediv_12_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_12_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_12_grad/Sum" + input: "train_op/gradients/compute_loss/truediv_12_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_12_grad/Neg" + op: "Neg" + input: "compute_loss/Slice_46" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_12_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_12_grad/Neg" + input: "compute_loss/add_48" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_12_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_12_grad/RealDiv_1" + input: "compute_loss/add_48" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_12_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_131_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/truediv_12_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_12_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_12_grad/mul" + input: "train_op/gradients/compute_loss/truediv_12_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_12_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_12_grad/Sum_1" + input: "train_op/gradients/compute_loss/truediv_12_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_12_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/truediv_12_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_12_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/truediv_12_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_12_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_12_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_12_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_12_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_12_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/truediv_12_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_12_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_13_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_13_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_13_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/truediv_13_grad/Shape" + input: "train_op/gradients/compute_loss/truediv_13_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_13_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/concat_131_grad/tuple/control_dependency_1" + input: "compute_loss/add_49" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_13_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_13_grad/RealDiv" + input: "train_op/gradients/compute_loss/truediv_13_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_13_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_13_grad/Sum" + input: "train_op/gradients/compute_loss/truediv_13_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_13_grad/Neg" + op: "Neg" + input: "compute_loss/Slice_47" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_13_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_13_grad/Neg" + input: "compute_loss/add_49" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_13_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_13_grad/RealDiv_1" + input: "compute_loss/add_49" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_13_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_131_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/truediv_13_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_13_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_13_grad/mul" + input: "train_op/gradients/compute_loss/truediv_13_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_13_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_13_grad/Sum_1" + input: "train_op/gradients/compute_loss/truediv_13_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_13_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/truediv_13_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_13_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/truediv_13_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_13_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_13_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_13_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_13_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_13_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/truediv_13_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_13_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_53_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_53_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_53_grad/stack/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: "train_op/gradients/compute_loss/Slice_53_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_53_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_53_grad/stack/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: "train_op/gradients/compute_loss/Slice_53_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_53/begin" + input: "train_op/gradients/compute_loss/Slice_53_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_53_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_53_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_53_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_53_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_53_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_53_grad/sub" + input: "compute_loss/Slice_53/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_53_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_53_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_53_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_53_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_53_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_53_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_53_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_53_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_53_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/truediv_14_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_53_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_53_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_53_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_53_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/add_53_grad/Shape" + input: "train_op/gradients/compute_loss/add_53_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_53_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_14_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_53_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_53_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_53_grad/Sum" + input: "train_op/gradients/compute_loss/add_53_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_53_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_14_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_53_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_53_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_53_grad/Sum_1" + input: "train_op/gradients/compute_loss/add_53_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_53_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_53_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_53_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/add_53_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_53_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_53_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_53_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_53_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_53_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/add_53_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_53_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_54_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_54_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_54_grad/stack/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: "train_op/gradients/compute_loss/Slice_54_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_54_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_54_grad/stack/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: "train_op/gradients/compute_loss/Slice_54_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_54/begin" + input: "train_op/gradients/compute_loss/Slice_54_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_54_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_54_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_54_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_54_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_54_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_54_grad/sub" + input: "compute_loss/Slice_54/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_54_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_54_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_54_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_54_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_54_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_54_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_54_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_54_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_54_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/truediv_15_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_54_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_54_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_54_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_54_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/add_54_grad/Shape" + input: "train_op/gradients/compute_loss/add_54_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_54_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_15_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_54_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_54_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_54_grad/Sum" + input: "train_op/gradients/compute_loss/add_54_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_54_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_15_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_54_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_54_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_54_grad/Sum_1" + input: "train_op/gradients/compute_loss/add_54_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_54_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_54_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_54_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/add_54_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_54_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_54_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_54_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_54_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_54_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/add_54_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_54_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/AddN_66" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling/add_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/clip_by_value/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_67" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/image_sampling/add_1_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/clip_by_value_1/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_68" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_1/sub_2_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_1/sub_3_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/sub_2_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_69" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling_1/sub_4_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling_1/sub_5_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling_1/sub_4_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling_1/split_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/AddN_68" + input: "train_op/gradients/AddN_69" + input: "compute_loss/image_sampling_1/split/split_dim" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/transpose_5_grad/InvertPermutation" + op: "InvertPermutation" + input: "compute_loss/transpose_5/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/transpose_5_grad/transpose" + op: "Transpose" + input: "train_op/gradients/compute_loss/image_sampling_2/split_grad/concat" + input: "train_op/gradients/compute_loss/transpose_5_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_19_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_19_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/transpose_7_grad/transpose" + input: "train_op/gradients/compute_loss/Reshape_19_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_93_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_93_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_93/axis" + input: "train_op/gradients/compute_loss/concat_93_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_93_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_93_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_93_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_93_grad/mod" + input: "train_op/gradients/compute_loss/concat_93_grad/Shape" + input: "train_op/gradients/compute_loss/concat_93_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_93_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_24_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_93_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_93_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_93_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_24_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_93_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_93_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_93_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_93_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_93_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_93_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_93_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_93_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_93_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_93_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_93_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_93_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_93_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_10_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_10_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/truediv_10_grad/Shape" + input: "train_op/gradients/compute_loss/truediv_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_10_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/concat_111_grad/tuple/control_dependency" + input: "compute_loss/add_39" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_10_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_10_grad/RealDiv" + input: "train_op/gradients/compute_loss/truediv_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_10_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_10_grad/Sum" + input: "train_op/gradients/compute_loss/truediv_10_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_10_grad/Neg" + op: "Neg" + input: "compute_loss/Slice_39" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_10_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_10_grad/Neg" + input: "compute_loss/add_39" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_10_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_10_grad/RealDiv_1" + input: "compute_loss/add_39" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_10_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_111_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/truediv_10_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_10_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_10_grad/mul" + input: "train_op/gradients/compute_loss/truediv_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_10_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_10_grad/Sum_1" + input: "train_op/gradients/compute_loss/truediv_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_10_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/truediv_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_10_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/truediv_10_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_10_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_10_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_10_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/truediv_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_10_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_11_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_11_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_11_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/truediv_11_grad/Shape" + input: "train_op/gradients/compute_loss/truediv_11_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_11_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/concat_111_grad/tuple/control_dependency_1" + input: "compute_loss/add_40" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_11_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_11_grad/RealDiv" + input: "train_op/gradients/compute_loss/truediv_11_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_11_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_11_grad/Sum" + input: "train_op/gradients/compute_loss/truediv_11_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_11_grad/Neg" + op: "Neg" + input: "compute_loss/Slice_40" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_11_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_11_grad/Neg" + input: "compute_loss/add_40" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_11_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_11_grad/RealDiv_1" + input: "compute_loss/add_40" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_11_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_111_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/truediv_11_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_11_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_11_grad/mul" + input: "train_op/gradients/compute_loss/truediv_11_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_11_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_11_grad/Sum_1" + input: "train_op/gradients/compute_loss/truediv_11_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_11_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/truediv_11_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_11_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/truediv_11_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_11_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_11_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_11_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_11_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_11_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/truediv_11_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_11_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_46_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_46_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_46_grad/stack/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: "train_op/gradients/compute_loss/Slice_46_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_46_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_46_grad/stack/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: "train_op/gradients/compute_loss/Slice_46_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_46/begin" + input: "train_op/gradients/compute_loss/Slice_46_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_46_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_46_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_46_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_46_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_46_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_46_grad/sub" + input: "compute_loss/Slice_46/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_46_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_46_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_46_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_46_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_46_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_46_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_46_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_46_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_46_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/truediv_12_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_46_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_48_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_48_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_48_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/add_48_grad/Shape" + input: "train_op/gradients/compute_loss/add_48_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_48_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_12_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_48_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_48_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_48_grad/Sum" + input: "train_op/gradients/compute_loss/add_48_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_48_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_12_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_48_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_48_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_48_grad/Sum_1" + input: "train_op/gradients/compute_loss/add_48_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_48_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_48_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_48_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/add_48_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_48_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_48_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_48_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_48_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_48_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/add_48_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_48_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_47_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_47_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_47_grad/stack/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: "train_op/gradients/compute_loss/Slice_47_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_47_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_47_grad/stack/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: "train_op/gradients/compute_loss/Slice_47_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_47/begin" + input: "train_op/gradients/compute_loss/Slice_47_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_47_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_47_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_47_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_47_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_47_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_47_grad/sub" + input: "compute_loss/Slice_47/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_47_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_47_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_47_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_47_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_47_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_47_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_47_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_47_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_47_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/truediv_13_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_47_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_49_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_49_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_49_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/add_49_grad/Shape" + input: "train_op/gradients/compute_loss/add_49_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_49_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_13_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_49_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_49_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_49_grad/Sum" + input: "train_op/gradients/compute_loss/add_49_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_49_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_13_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_49_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_49_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_49_grad/Sum_1" + input: "train_op/gradients/compute_loss/add_49_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_49_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_49_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_49_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/add_49_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_49_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_49_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_49_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_49_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_49_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/add_49_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_49_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/AddN_70" + op: "AddN" + input: "train_op/gradients/compute_loss/add_53_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/add_54_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_53_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_55_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_55_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_55_grad/stack/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: "train_op/gradients/compute_loss/Slice_55_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_55_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_55_grad/stack/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: "train_op/gradients/compute_loss/Slice_55_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_55/begin" + input: "train_op/gradients/compute_loss/Slice_55_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_55_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_55_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_55_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_55_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_55_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_55_grad/sub" + input: "compute_loss/Slice_55/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_55_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_55_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_55_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_55_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_55_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_55_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_55_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_55_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_55_grad/Pad" + op: "Pad" + input: "train_op/gradients/AddN_70" + input: "train_op/gradients/compute_loss/Slice_55_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_71" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling/sub_2_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling/sub_3_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/sub_2_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_72" + op: "AddN" + input: "train_op/gradients/compute_loss/image_sampling/sub_4_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/image_sampling/sub_5_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/image_sampling/sub_4_grad/Neg" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/image_sampling/split_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/AddN_71" + input: "train_op/gradients/AddN_72" + input: "compute_loss/image_sampling/split/split_dim" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/transpose_3_grad/InvertPermutation" + op: "InvertPermutation" + input: "compute_loss/transpose_3/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/transpose_3_grad/transpose" + op: "Transpose" + input: "train_op/gradients/compute_loss/image_sampling_1/split_grad/concat" + input: "train_op/gradients/compute_loss/transpose_3_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_14_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_14_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/transpose_5_grad/transpose" + input: "train_op/gradients/compute_loss/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_73_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_73_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_73/axis" + input: "train_op/gradients/compute_loss/concat_73_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_73_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_73_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_73_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_73_grad/mod" + input: "train_op/gradients/compute_loss/concat_73_grad/Shape" + input: "train_op/gradients/compute_loss/concat_73_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_73_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_19_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_73_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_73_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_73_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_19_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_73_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_73_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_73_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_73_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_73_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_73_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_73_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_73_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_73_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_73_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_73_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_73_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_73_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_8_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_8_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/truediv_8_grad/Shape" + input: "train_op/gradients/compute_loss/truediv_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_8_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/concat_93_grad/tuple/control_dependency" + input: "compute_loss/add_34" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_8_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_8_grad/RealDiv" + input: "train_op/gradients/compute_loss/truediv_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_8_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_8_grad/Sum" + input: "train_op/gradients/compute_loss/truediv_8_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_8_grad/Neg" + op: "Neg" + input: "compute_loss/Slice_32" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_8_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_8_grad/Neg" + input: "compute_loss/add_34" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_8_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_8_grad/RealDiv_1" + input: "compute_loss/add_34" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_8_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_93_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/truediv_8_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_8_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_8_grad/mul" + input: "train_op/gradients/compute_loss/truediv_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_8_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_8_grad/Sum_1" + input: "train_op/gradients/compute_loss/truediv_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_8_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/truediv_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_8_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/truediv_8_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_8_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_8_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_8_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/truediv_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_8_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_9_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_9_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/truediv_9_grad/Shape" + input: "train_op/gradients/compute_loss/truediv_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_9_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/concat_93_grad/tuple/control_dependency_1" + input: "compute_loss/add_35" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_9_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_9_grad/RealDiv" + input: "train_op/gradients/compute_loss/truediv_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_9_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_9_grad/Sum" + input: "train_op/gradients/compute_loss/truediv_9_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_9_grad/Neg" + op: "Neg" + input: "compute_loss/Slice_33" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_9_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_9_grad/Neg" + input: "compute_loss/add_35" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_9_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_9_grad/RealDiv_1" + input: "compute_loss/add_35" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_9_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_93_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/truediv_9_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_9_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_9_grad/mul" + input: "train_op/gradients/compute_loss/truediv_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_9_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_9_grad/Sum_1" + input: "train_op/gradients/compute_loss/truediv_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_9_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/truediv_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_9_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/truediv_9_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_9_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_9_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_9_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/truediv_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_9_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_39_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_39_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_39_grad/stack/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: "train_op/gradients/compute_loss/Slice_39_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_39_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_39_grad/stack/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: "train_op/gradients/compute_loss/Slice_39_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_39/begin" + input: "train_op/gradients/compute_loss/Slice_39_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_39_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_39_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_39_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_39_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_39_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_39_grad/sub" + input: "compute_loss/Slice_39/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_39_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_39_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_39_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_39_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_39_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_39_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_39_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_39_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_39_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/truediv_10_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_39_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_39_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_39_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_39_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/add_39_grad/Shape" + input: "train_op/gradients/compute_loss/add_39_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_39_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_10_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_39_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_39_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_39_grad/Sum" + input: "train_op/gradients/compute_loss/add_39_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_39_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_10_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_39_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_39_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_39_grad/Sum_1" + input: "train_op/gradients/compute_loss/add_39_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_39_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_39_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_39_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/add_39_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_39_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_39_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_39_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_39_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_39_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/add_39_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_39_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_40_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_40_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_40_grad/stack/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: "train_op/gradients/compute_loss/Slice_40_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_40_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_40_grad/stack/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: "train_op/gradients/compute_loss/Slice_40_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_40/begin" + input: "train_op/gradients/compute_loss/Slice_40_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_40_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_40_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_40_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_40_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_40_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_40_grad/sub" + input: "compute_loss/Slice_40/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_40_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_40_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_40_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_40_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_40_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_40_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_40_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_40_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_40_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/truediv_11_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_40_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_40_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_40_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_40_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/add_40_grad/Shape" + input: "train_op/gradients/compute_loss/add_40_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_40_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_11_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_40_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_40_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_40_grad/Sum" + input: "train_op/gradients/compute_loss/add_40_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_40_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_11_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_40_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_40_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_40_grad/Sum_1" + input: "train_op/gradients/compute_loss/add_40_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_40_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_40_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_40_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/add_40_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_40_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_40_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_40_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_40_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_40_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/add_40_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_40_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/AddN_73" + op: "AddN" + input: "train_op/gradients/compute_loss/add_48_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/add_49_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_48_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_48_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_48_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_48_grad/stack/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: "train_op/gradients/compute_loss/Slice_48_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_48_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_48_grad/stack/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: "train_op/gradients/compute_loss/Slice_48_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_48/begin" + input: "train_op/gradients/compute_loss/Slice_48_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_48_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_48_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_48_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_48_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_48_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_48_grad/sub" + input: "compute_loss/Slice_48/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_48_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_48_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_48_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_48_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_48_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_48_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_48_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_48_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_48_grad/Pad" + op: "Pad" + input: "train_op/gradients/AddN_73" + input: "train_op/gradients/compute_loss/Slice_48_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_74" + op: "AddN" + input: "train_op/gradients/compute_loss/Slice_53_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_54_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_55_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Slice_53_grad/Pad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_55_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/AddN_74" + input: "compute_loss/Reshape_38" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_55_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/MatMul_54" + input: "train_op/gradients/AddN_74" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_55_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_55_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_55_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_55_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_55_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_55_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_55_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_55_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_55_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_55_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_55_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/transpose_1_grad/InvertPermutation" + op: "InvertPermutation" + input: "compute_loss/transpose_1/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/transpose_1_grad/transpose" + op: "Transpose" + input: "train_op/gradients/compute_loss/image_sampling/split_grad/concat" + input: "train_op/gradients/compute_loss/transpose_1_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_9_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_9_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/transpose_3_grad/transpose" + input: "train_op/gradients/compute_loss/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_55_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_55_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_55/axis" + input: "train_op/gradients/compute_loss/concat_55_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_55_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_55_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_55_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_55_grad/mod" + input: "train_op/gradients/compute_loss/concat_55_grad/Shape" + input: "train_op/gradients/compute_loss/concat_55_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_55_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_14_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_55_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_55_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_55_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_14_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_55_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_55_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_55_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_55_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_55_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_55_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_55_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_55_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_55_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_55_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_55_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_55_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_55_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_6_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_6_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/truediv_6_grad/Shape" + input: "train_op/gradients/compute_loss/truediv_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_6_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/concat_73_grad/tuple/control_dependency" + input: "compute_loss/add_25" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_6_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_6_grad/RealDiv" + input: "train_op/gradients/compute_loss/truediv_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_6_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_6_grad/Sum" + input: "train_op/gradients/compute_loss/truediv_6_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_6_grad/Neg" + op: "Neg" + input: "compute_loss/Slice_25" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_6_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_6_grad/Neg" + input: "compute_loss/add_25" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_6_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_6_grad/RealDiv_1" + input: "compute_loss/add_25" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_6_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_73_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/truediv_6_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_6_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_6_grad/mul" + input: "train_op/gradients/compute_loss/truediv_6_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_6_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_6_grad/Sum_1" + input: "train_op/gradients/compute_loss/truediv_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_6_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/truediv_6_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_6_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/truediv_6_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_6_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_6_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_6_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_6_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/truediv_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_6_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_7_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_7_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/truediv_7_grad/Shape" + input: "train_op/gradients/compute_loss/truediv_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_7_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/concat_73_grad/tuple/control_dependency_1" + input: "compute_loss/add_26" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_7_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_7_grad/RealDiv" + input: "train_op/gradients/compute_loss/truediv_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_7_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_7_grad/Sum" + input: "train_op/gradients/compute_loss/truediv_7_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_7_grad/Neg" + op: "Neg" + input: "compute_loss/Slice_26" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_7_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_7_grad/Neg" + input: "compute_loss/add_26" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_7_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_7_grad/RealDiv_1" + input: "compute_loss/add_26" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_7_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_73_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/truediv_7_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_7_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_7_grad/mul" + input: "train_op/gradients/compute_loss/truediv_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_7_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_7_grad/Sum_1" + input: "train_op/gradients/compute_loss/truediv_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_7_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/truediv_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_7_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/truediv_7_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_7_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_7_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_7_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/truediv_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_7_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_32_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_32_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_32_grad/stack/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: "train_op/gradients/compute_loss/Slice_32_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_32_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_32_grad/stack/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: "train_op/gradients/compute_loss/Slice_32_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_32/begin" + input: "train_op/gradients/compute_loss/Slice_32_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_32_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_32_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_32_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_32_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_32_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_32_grad/sub" + input: "compute_loss/Slice_32/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_32_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_32_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_32_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_32_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_32_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_32_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_32_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_32_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_32_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/truediv_8_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_32_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_34_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_34_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_34_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/add_34_grad/Shape" + input: "train_op/gradients/compute_loss/add_34_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_34_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_8_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_34_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_34_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_34_grad/Sum" + input: "train_op/gradients/compute_loss/add_34_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_34_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_8_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_34_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_34_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_34_grad/Sum_1" + input: "train_op/gradients/compute_loss/add_34_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_34_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_34_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_34_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/add_34_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_34_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_34_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_34_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_34_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_34_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/add_34_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_34_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_33_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_33_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_33_grad/stack/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: "train_op/gradients/compute_loss/Slice_33_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_33_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_33_grad/stack/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: "train_op/gradients/compute_loss/Slice_33_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_33/begin" + input: "train_op/gradients/compute_loss/Slice_33_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_33_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_33_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_33_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_33_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_33_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_33_grad/sub" + input: "compute_loss/Slice_33/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_33_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_33_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_33_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_33_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_33_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_33_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_33_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_33_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_33_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/truediv_9_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_33_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_35_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_35_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_35_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/add_35_grad/Shape" + input: "train_op/gradients/compute_loss/add_35_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_35_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_9_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_35_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_35_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_35_grad/Sum" + input: "train_op/gradients/compute_loss/add_35_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_35_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_9_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_35_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_35_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_35_grad/Sum_1" + input: "train_op/gradients/compute_loss/add_35_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_35_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_35_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_35_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/add_35_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_35_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_35_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_35_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_35_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_35_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/add_35_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_35_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/AddN_75" + op: "AddN" + input: "train_op/gradients/compute_loss/add_39_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/add_40_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_39_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_41_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_41_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_41_grad/stack/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: "train_op/gradients/compute_loss/Slice_41_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_41_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_41_grad/stack/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: "train_op/gradients/compute_loss/Slice_41_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_41/begin" + input: "train_op/gradients/compute_loss/Slice_41_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_41_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_41_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_41_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_41_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_41_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_41_grad/sub" + input: "compute_loss/Slice_41/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_41_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_41_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_41_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_41_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_41_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_41_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_41_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_41_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_41_grad/Pad" + op: "Pad" + input: "train_op/gradients/AddN_75" + input: "train_op/gradients/compute_loss/Slice_41_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_76" + op: "AddN" + input: "train_op/gradients/compute_loss/Slice_46_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_47_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_48_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Slice_46_grad/Pad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_48_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/AddN_76" + input: "compute_loss/Reshape_33" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_48_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/MatMul_47" + input: "train_op/gradients/AddN_76" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_48_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_48_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_48_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_48_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_48_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_48_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_48_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_48_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_48_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_48_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_48_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_54_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/MatMul_55_grad/tuple/control_dependency" + input: "compute_loss/concat_145" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_54_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/concat_148" + input: "train_op/gradients/compute_loss/MatMul_55_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_54_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_54_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_54_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_54_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_54_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_54_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_54_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_54_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_54_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_54_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_54_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_38_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\020\000\000\0004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_38_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/MatMul_55_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Reshape_38_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_4_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_4_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/transpose_1_grad/transpose" + input: "train_op/gradients/compute_loss/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_35_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_35_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_35/axis" + input: "train_op/gradients/compute_loss/concat_35_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_35_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_35_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_35_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_35_grad/mod" + input: "train_op/gradients/compute_loss/concat_35_grad/Shape" + input: "train_op/gradients/compute_loss/concat_35_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_35_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_9_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_35_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_35_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_35_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_9_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_35_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_35_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_35_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_35_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_35_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_35_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_35_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_35_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_35_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_35_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_35_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_35_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_35_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_4_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_4_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/truediv_4_grad/Shape" + input: "train_op/gradients/compute_loss/truediv_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_4_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/concat_55_grad/tuple/control_dependency" + input: "compute_loss/add_20" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_4_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_4_grad/RealDiv" + input: "train_op/gradients/compute_loss/truediv_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_4_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_4_grad/Sum" + input: "train_op/gradients/compute_loss/truediv_4_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_4_grad/Neg" + op: "Neg" + input: "compute_loss/Slice_18" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_4_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_4_grad/Neg" + input: "compute_loss/add_20" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_4_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_4_grad/RealDiv_1" + input: "compute_loss/add_20" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_4_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_55_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/truediv_4_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_4_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_4_grad/mul" + input: "train_op/gradients/compute_loss/truediv_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_4_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_4_grad/Sum_1" + input: "train_op/gradients/compute_loss/truediv_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/truediv_4_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_4_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/truediv_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_4_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_4_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_4_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/truediv_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_4_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_5_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_5_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/truediv_5_grad/Shape" + input: "train_op/gradients/compute_loss/truediv_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_5_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/concat_55_grad/tuple/control_dependency_1" + input: "compute_loss/add_21" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_5_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_5_grad/RealDiv" + input: "train_op/gradients/compute_loss/truediv_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_5_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_5_grad/Sum" + input: "train_op/gradients/compute_loss/truediv_5_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_5_grad/Neg" + op: "Neg" + input: "compute_loss/Slice_19" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_5_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_5_grad/Neg" + input: "compute_loss/add_21" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_5_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_5_grad/RealDiv_1" + input: "compute_loss/add_21" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_5_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_55_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/truediv_5_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_5_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_5_grad/mul" + input: "train_op/gradients/compute_loss/truediv_5_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_5_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_5_grad/Sum_1" + input: "train_op/gradients/compute_loss/truediv_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/truediv_5_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_5_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/truediv_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_5_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_5_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_5_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/truediv_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_5_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_25_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_25_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_25_grad/stack/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: "train_op/gradients/compute_loss/Slice_25_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_25_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_25_grad/stack/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: "train_op/gradients/compute_loss/Slice_25_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_25/begin" + input: "train_op/gradients/compute_loss/Slice_25_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_25_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_25_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_25_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_25_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_25_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_25_grad/sub" + input: "compute_loss/Slice_25/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_25_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_25_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_25_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_25_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_25_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_25_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_25_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_25_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_25_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/truediv_6_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_25_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_25_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_25_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_25_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/add_25_grad/Shape" + input: "train_op/gradients/compute_loss/add_25_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_25_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_6_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_25_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_25_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_25_grad/Sum" + input: "train_op/gradients/compute_loss/add_25_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_25_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_6_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_25_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_25_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_25_grad/Sum_1" + input: "train_op/gradients/compute_loss/add_25_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_25_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_25_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_25_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/add_25_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_25_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_25_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_25_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_25_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_25_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/add_25_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_25_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_26_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_26_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_26_grad/stack/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: "train_op/gradients/compute_loss/Slice_26_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_26_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_26_grad/stack/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: "train_op/gradients/compute_loss/Slice_26_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_26/begin" + input: "train_op/gradients/compute_loss/Slice_26_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_26_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_26_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_26_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_26_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_26_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_26_grad/sub" + input: "compute_loss/Slice_26/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_26_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_26_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_26_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_26_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_26_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_26_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_26_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_26_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_26_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/truediv_7_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_26_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_26_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_26_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_26_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/add_26_grad/Shape" + input: "train_op/gradients/compute_loss/add_26_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_26_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_7_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_26_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_26_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_26_grad/Sum" + input: "train_op/gradients/compute_loss/add_26_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_26_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_7_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_26_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_26_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_26_grad/Sum_1" + input: "train_op/gradients/compute_loss/add_26_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_26_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_26_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_26_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/add_26_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_26_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_26_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_26_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_26_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_26_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/add_26_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_26_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/AddN_77" + op: "AddN" + input: "train_op/gradients/compute_loss/add_34_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/add_35_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_34_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_34_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_34_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_34_grad/stack/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: "train_op/gradients/compute_loss/Slice_34_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_34_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_34_grad/stack/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: "train_op/gradients/compute_loss/Slice_34_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_34/begin" + input: "train_op/gradients/compute_loss/Slice_34_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_34_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_34_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_34_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_34_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_34_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_34_grad/sub" + input: "compute_loss/Slice_34/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_34_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_34_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_34_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_34_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_34_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_34_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_34_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_34_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_34_grad/Pad" + op: "Pad" + input: "train_op/gradients/AddN_77" + input: "train_op/gradients/compute_loss/Slice_34_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_78" + op: "AddN" + input: "train_op/gradients/compute_loss/Slice_39_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_40_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_41_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Slice_39_grad/Pad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_41_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/AddN_78" + input: "compute_loss/Reshape_28" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_41_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/MatMul_40" + input: "train_op/gradients/AddN_78" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_41_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_41_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_41_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_41_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_41_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_41_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_41_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_41_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_41_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_41_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_41_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_47_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/MatMul_48_grad/tuple/control_dependency" + input: "compute_loss/concat_127" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_47_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/concat_130" + input: "train_op/gradients/compute_loss/MatMul_48_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_47_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_47_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_47_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_47_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_47_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_47_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_47_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_47_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_47_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_47_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_47_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_33_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\020\000\000\0004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_33_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/MatMul_48_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Reshape_33_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_145_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_145_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_145/axis" + input: "train_op/gradients/compute_loss/concat_145_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_145_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_145_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_145_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_145_grad/mod" + input: "train_op/gradients/compute_loss/concat_145_grad/Shape" + input: "train_op/gradients/compute_loss/concat_145_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_145_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_54_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_145_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_145_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_145_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_54_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_145_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_145_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_145_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_145_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_145_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_145_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_145_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_145_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_145_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_145_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_145_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_145_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_145_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_37_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_37_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/Reshape_38_grad/Reshape" + input: "train_op/gradients/compute_loss/Reshape_37_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_17_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_17_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_17/axis" + input: "train_op/gradients/compute_loss/concat_17_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_17_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_17_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_17_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_17_grad/mod" + input: "train_op/gradients/compute_loss/concat_17_grad/Shape" + input: "train_op/gradients/compute_loss/concat_17_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_17_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_4_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_17_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_17_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_17_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_4_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_17_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_17_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_17_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_17_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_17_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_17_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_17_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_17_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_17_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_17_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_17_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_17_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_17_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_2_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_2_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/truediv_2_grad/Shape" + input: "train_op/gradients/compute_loss/truediv_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_2_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/concat_35_grad/tuple/control_dependency" + input: "compute_loss/add_11" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_2_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_2_grad/RealDiv" + input: "train_op/gradients/compute_loss/truediv_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_2_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_2_grad/Sum" + input: "train_op/gradients/compute_loss/truediv_2_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_2_grad/Neg" + op: "Neg" + input: "compute_loss/Slice_11" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_2_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_2_grad/Neg" + input: "compute_loss/add_11" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_2_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_2_grad/RealDiv_1" + input: "compute_loss/add_11" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_2_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_35_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/truediv_2_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_2_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_2_grad/mul" + input: "train_op/gradients/compute_loss/truediv_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_2_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_2_grad/Sum_1" + input: "train_op/gradients/compute_loss/truediv_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/truediv_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_2_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/truediv_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_2_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_2_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/truediv_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_2_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_3_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_3_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/truediv_3_grad/Shape" + input: "train_op/gradients/compute_loss/truediv_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_3_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/concat_35_grad/tuple/control_dependency_1" + input: "compute_loss/add_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_3_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_3_grad/RealDiv" + input: "train_op/gradients/compute_loss/truediv_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_3_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_3_grad/Sum" + input: "train_op/gradients/compute_loss/truediv_3_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_3_grad/Neg" + op: "Neg" + input: "compute_loss/Slice_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_3_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_3_grad/Neg" + input: "compute_loss/add_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_3_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_3_grad/RealDiv_1" + input: "compute_loss/add_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_3_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_35_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/truediv_3_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_3_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_3_grad/mul" + input: "train_op/gradients/compute_loss/truediv_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_3_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_3_grad/Sum_1" + input: "train_op/gradients/compute_loss/truediv_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/truediv_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_3_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/truediv_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_3_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_3_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/truediv_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_3_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_18_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_18_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_18_grad/stack/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: "train_op/gradients/compute_loss/Slice_18_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_18_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_18_grad/stack/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: "train_op/gradients/compute_loss/Slice_18_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_18/begin" + input: "train_op/gradients/compute_loss/Slice_18_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_18_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_18_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_18_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_18_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_18_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_18_grad/sub" + input: "compute_loss/Slice_18/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_18_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_18_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_18_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_18_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_18_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_18_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_18_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_18_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_18_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/truediv_4_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_18_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_20_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_20_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_20_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/add_20_grad/Shape" + input: "train_op/gradients/compute_loss/add_20_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_20_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_4_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_20_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_20_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_20_grad/Sum" + input: "train_op/gradients/compute_loss/add_20_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_20_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_4_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_20_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_20_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_20_grad/Sum_1" + input: "train_op/gradients/compute_loss/add_20_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_20_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_20_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_20_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/add_20_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_20_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_20_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_20_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_20_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_20_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/add_20_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_20_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_19_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_19_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_19_grad/stack/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: "train_op/gradients/compute_loss/Slice_19_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_19_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_19_grad/stack/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: "train_op/gradients/compute_loss/Slice_19_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_19/begin" + input: "train_op/gradients/compute_loss/Slice_19_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_19_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_19_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_19_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_19_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_19_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_19_grad/sub" + input: "compute_loss/Slice_19/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_19_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_19_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_19_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_19_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_19_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_19_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_19_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_19_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_19_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/truediv_5_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_19_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_21_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_21_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_21_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/add_21_grad/Shape" + input: "train_op/gradients/compute_loss/add_21_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_21_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_5_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_21_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_21_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_21_grad/Sum" + input: "train_op/gradients/compute_loss/add_21_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_21_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_5_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_21_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_21_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_21_grad/Sum_1" + input: "train_op/gradients/compute_loss/add_21_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_21_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_21_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_21_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/add_21_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_21_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_21_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_21_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_21_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_21_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/add_21_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_21_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/AddN_79" + op: "AddN" + input: "train_op/gradients/compute_loss/add_25_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/add_26_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_25_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_27_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_27_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_27_grad/stack/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: "train_op/gradients/compute_loss/Slice_27_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_27_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_27_grad/stack/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: "train_op/gradients/compute_loss/Slice_27_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_27/begin" + input: "train_op/gradients/compute_loss/Slice_27_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_27_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_27_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_27_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_27_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_27_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_27_grad/sub" + input: "compute_loss/Slice_27/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_27_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_27_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_27_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_27_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_27_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_27_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_27_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_27_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_27_grad/Pad" + op: "Pad" + input: "train_op/gradients/AddN_79" + input: "train_op/gradients/compute_loss/Slice_27_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_80" + op: "AddN" + input: "train_op/gradients/compute_loss/Slice_32_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_33_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_34_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Slice_32_grad/Pad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_34_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/AddN_80" + input: "compute_loss/Reshape_23" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_34_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/MatMul_33" + input: "train_op/gradients/AddN_80" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_34_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_34_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_34_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_34_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_34_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_34_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_34_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_34_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_34_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_34_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_34_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_40_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/MatMul_41_grad/tuple/control_dependency" + input: "compute_loss/concat_107" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_40_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/concat_110" + input: "train_op/gradients/compute_loss/MatMul_41_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_40_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_40_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_40_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_40_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_40_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_40_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_40_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_40_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_40_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_40_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_40_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_28_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\004\000\000\000 \000\000\000h\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_28_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/MatMul_41_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Reshape_28_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_127_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_127_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_127/axis" + input: "train_op/gradients/compute_loss/concat_127_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_127_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_127_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_127_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_127_grad/mod" + input: "train_op/gradients/compute_loss/concat_127_grad/Shape" + input: "train_op/gradients/compute_loss/concat_127_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_127_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_47_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_127_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_127_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_127_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_47_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_127_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_127_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_127_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_127_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_127_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_127_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_127_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_127_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_127_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_127_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_127_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_127_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_127_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_32_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_32_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/Reshape_33_grad/Reshape" + input: "train_op/gradients/compute_loss/Reshape_32_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_144_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_144_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_144/axis" + input: "train_op/gradients/compute_loss/concat_144_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_144_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_144_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_144_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_144_grad/mod" + input: "train_op/gradients/compute_loss/concat_144_grad/Shape" + input: "train_op/gradients/compute_loss/concat_144_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_144_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_145_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_144_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_144_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_144_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_145_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_144_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_144_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_144_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_144_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_144_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_144_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_144_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_144_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_144_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_144_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_144_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_144_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_144_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_146_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_146_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_146/axis" + input: "train_op/gradients/compute_loss/concat_146_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_146_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_146_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_146_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_146_grad/mod" + input: "train_op/gradients/compute_loss/concat_146_grad/Shape" + input: "train_op/gradients/compute_loss/concat_146_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_146_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_37_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_146_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_146_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_146_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_37_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_146_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_146_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_146_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_146_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_146_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_146_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_146_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_146_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_146_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_146_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_146_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_146_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_146_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/truediv_grad/Shape" + input: "train_op/gradients/compute_loss/truediv_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/concat_17_grad/tuple/control_dependency" + input: "compute_loss/add_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_grad/RealDiv" + input: "train_op/gradients/compute_loss/truediv_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_grad/Sum" + input: "train_op/gradients/compute_loss/truediv_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_grad/Neg" + op: "Neg" + input: "compute_loss/Slice_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_grad/Neg" + input: "compute_loss/add_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_grad/RealDiv_1" + input: "compute_loss/add_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_17_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/truediv_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_grad/mul" + input: "train_op/gradients/compute_loss/truediv_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_grad/Sum_1" + input: "train_op/gradients/compute_loss/truediv_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/truediv_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/truediv_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/truediv_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/truediv_1_grad/Shape" + input: "train_op/gradients/compute_loss/truediv_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_1_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/compute_loss/concat_17_grad/tuple/control_dependency_1" + input: "compute_loss/add_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_1_grad/RealDiv" + input: "train_op/gradients/compute_loss/truediv_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_1_grad/Sum" + input: "train_op/gradients/compute_loss/truediv_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_1_grad/Neg" + op: "Neg" + input: "compute_loss/Slice_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_1_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_1_grad/Neg" + input: "compute_loss/add_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_1_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/compute_loss/truediv_1_grad/RealDiv_1" + input: "compute_loss/add_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_1_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_17_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/truediv_1_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_1_grad/mul" + input: "train_op/gradients/compute_loss/truediv_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/truediv_1_grad/Sum_1" + input: "train_op/gradients/compute_loss/truediv_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/truediv_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/truediv_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/truediv_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/truediv_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/truediv_1_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/truediv_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/truediv_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_11_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_11_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_11_grad/stack/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: "train_op/gradients/compute_loss/Slice_11_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_11_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_11_grad/stack/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: "train_op/gradients/compute_loss/Slice_11_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_11/begin" + input: "train_op/gradients/compute_loss/Slice_11_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_11_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_11_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_11_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_11_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_11_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_11_grad/sub" + input: "compute_loss/Slice_11/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_11_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_11_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_11_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_11_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_11_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_11_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_11_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_11_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_11_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/truediv_2_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_11_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_11_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_11_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_11_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/add_11_grad/Shape" + input: "train_op/gradients/compute_loss/add_11_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_11_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_2_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_11_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_11_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_11_grad/Sum" + input: "train_op/gradients/compute_loss/add_11_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_11_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_2_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_11_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_11_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_11_grad/Sum_1" + input: "train_op/gradients/compute_loss/add_11_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_11_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_11_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_11_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/add_11_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_11_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_11_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_11_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_11_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_11_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/add_11_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_11_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_12_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_12_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_12_grad/stack/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: "train_op/gradients/compute_loss/Slice_12_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_12_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_12_grad/stack/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: "train_op/gradients/compute_loss/Slice_12_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_12/begin" + input: "train_op/gradients/compute_loss/Slice_12_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_12_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_12_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_12_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_12_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_12_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_12_grad/sub" + input: "compute_loss/Slice_12/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_12_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_12_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_12_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_12_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_12_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_12_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_12_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_12_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_12_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/truediv_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_12_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_12_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_12_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_12_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/add_12_grad/Shape" + input: "train_op/gradients/compute_loss/add_12_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_12_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_12_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_12_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_12_grad/Sum" + input: "train_op/gradients/compute_loss/add_12_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_12_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_12_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_12_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_12_grad/Sum_1" + input: "train_op/gradients/compute_loss/add_12_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_12_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_12_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_12_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/add_12_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_12_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_12_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_12_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_12_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_12_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/add_12_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_12_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/AddN_81" + op: "AddN" + input: "train_op/gradients/compute_loss/add_20_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/add_21_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_20_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_20_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_20_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_20_grad/stack/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: "train_op/gradients/compute_loss/Slice_20_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_20_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_20_grad/stack/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: "train_op/gradients/compute_loss/Slice_20_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_20/begin" + input: "train_op/gradients/compute_loss/Slice_20_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_20_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_20_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_20_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_20_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_20_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_20_grad/sub" + input: "compute_loss/Slice_20/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_20_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_20_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_20_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_20_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_20_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_20_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_20_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_20_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_20_grad/Pad" + op: "Pad" + input: "train_op/gradients/AddN_81" + input: "train_op/gradients/compute_loss/Slice_20_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_82" + op: "AddN" + input: "train_op/gradients/compute_loss/Slice_25_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_26_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_27_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Slice_25_grad/Pad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_27_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/AddN_82" + input: "compute_loss/Reshape_18" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_27_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/MatMul_26" + input: "train_op/gradients/AddN_82" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_27_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_27_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_27_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_27_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_27_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_27_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_27_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_27_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_27_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_27_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_27_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_33_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/MatMul_34_grad/tuple/control_dependency" + input: "compute_loss/concat_89" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_33_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/concat_92" + input: "train_op/gradients/compute_loss/MatMul_34_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_33_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_33_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_33_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_33_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_33_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_33_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_33_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_33_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_33_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_33_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_33_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_23_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\004\000\000\000 \000\000\000h\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_23_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/MatMul_34_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Reshape_23_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_107_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_107_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_107/axis" + input: "train_op/gradients/compute_loss/concat_107_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_107_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_107_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_107_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_107_grad/mod" + input: "train_op/gradients/compute_loss/concat_107_grad/Shape" + input: "train_op/gradients/compute_loss/concat_107_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_107_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_40_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_107_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_107_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_107_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_40_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_107_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_107_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_107_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_107_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_107_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_107_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_107_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_107_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_107_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_107_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_107_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_107_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_107_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_27_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_27_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/Reshape_28_grad/Reshape" + input: "train_op/gradients/compute_loss/Reshape_27_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_126_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_126_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_126/axis" + input: "train_op/gradients/compute_loss/concat_126_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_126_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_126_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_126_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_126_grad/mod" + input: "train_op/gradients/compute_loss/concat_126_grad/Shape" + input: "train_op/gradients/compute_loss/concat_126_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_126_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_127_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_126_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_126_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_126_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_127_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_126_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_126_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_126_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_126_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_126_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_126_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_126_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_126_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_126_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_126_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_126_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_126_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_126_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_128_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_128_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_128/axis" + input: "train_op/gradients/compute_loss/concat_128_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_128_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_128_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_128_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_128_grad/mod" + input: "train_op/gradients/compute_loss/concat_128_grad/Shape" + input: "train_op/gradients/compute_loss/concat_128_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_128_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_32_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_128_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_128_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_128_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_32_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_128_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_128_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_128_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_128_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_128_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_128_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_128_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_128_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_128_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_128_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_128_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_128_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_128_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_15_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\003\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_15_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/concat_144_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Squeeze_15_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_70_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_70_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/concat_144_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/ExpandDims_70_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_43_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_43_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_43_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/mul_43_grad/Shape" + input: "train_op/gradients/compute_loss/mul_43_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_43_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_146_grad/tuple/control_dependency" + input: "compute_loss/Reshape_35" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_43_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/mul_43_grad/Mul" + input: "train_op/gradients/compute_loss/mul_43_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_43_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_43_grad/Sum" + input: "train_op/gradients/compute_loss/mul_43_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_43_grad/Mul_1" + op: "Mul" + input: "compute_loss/MatMul_53" + input: "train_op/gradients/compute_loss/concat_146_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_43_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/mul_43_grad/Mul_1" + input: "train_op/gradients/compute_loss/mul_43_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_43_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_43_grad/Sum_1" + input: "train_op/gradients/compute_loss/mul_43_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_43_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/mul_43_grad/Reshape" + input: "^train_op/gradients/compute_loss/mul_43_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/mul_43_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_43_grad/Reshape" + input: "^train_op/gradients/compute_loss/mul_43_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_43_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_43_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_43_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/mul_43_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_43_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_4_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_4_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_4_grad/stack/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: "train_op/gradients/compute_loss/Slice_4_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_4_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_4_grad/stack/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: "train_op/gradients/compute_loss/Slice_4_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_4/begin" + input: "train_op/gradients/compute_loss/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_4_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_4_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_4_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_4_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_4_grad/sub" + input: "compute_loss/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_4_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_4_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_4_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_4_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_4_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_4_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/truediv_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_6_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_6_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/add_6_grad/Shape" + input: "train_op/gradients/compute_loss/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_6_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_6_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_6_grad/Sum" + input: "train_op/gradients/compute_loss/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_6_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_6_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_6_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_6_grad/Sum_1" + input: "train_op/gradients/compute_loss/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_6_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_6_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_6_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/add_6_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_6_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_6_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_6_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_6_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/add_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_6_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_5_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_5_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_5_grad/stack/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: "train_op/gradients/compute_loss/Slice_5_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_5_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_5_grad/stack/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: "train_op/gradients/compute_loss/Slice_5_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_5/begin" + input: "train_op/gradients/compute_loss/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_5_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_5_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_5_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_5_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_5_grad/sub" + input: "compute_loss/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_5_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_5_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_5_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_5_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_5_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_5_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/truediv_1_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_7_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_7_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/add_7_grad/Shape" + input: "train_op/gradients/compute_loss/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_7_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_1_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_7_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_7_grad/Sum" + input: "train_op/gradients/compute_loss/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_7_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/truediv_1_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/add_7_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/add_7_grad/Sum_1" + input: "train_op/gradients/compute_loss/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_7_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/add_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_7_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/add_7_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/add_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/add_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_7_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/add_7_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/add_7_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/add_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_7_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/AddN_83" + op: "AddN" + input: "train_op/gradients/compute_loss/add_11_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/add_12_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_11_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_13_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_13_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_13_grad/stack/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: "train_op/gradients/compute_loss/Slice_13_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_13_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_13_grad/stack/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: "train_op/gradients/compute_loss/Slice_13_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_13/begin" + input: "train_op/gradients/compute_loss/Slice_13_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_13_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_13_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_13_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_13_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_13_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_13_grad/sub" + input: "compute_loss/Slice_13/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_13_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_13_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_13_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_13_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_13_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_13_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_13_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_13_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_13_grad/Pad" + op: "Pad" + input: "train_op/gradients/AddN_83" + input: "train_op/gradients/compute_loss/Slice_13_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_84" + op: "AddN" + input: "train_op/gradients/compute_loss/Slice_18_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_19_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_20_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Slice_18_grad/Pad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_20_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/AddN_84" + input: "compute_loss/Reshape_13" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_20_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/MatMul_19" + input: "train_op/gradients/AddN_84" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_20_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_20_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_20_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_20_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_20_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_20_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_20_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_20_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_20_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_20_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_20_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_26_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/MatMul_27_grad/tuple/control_dependency" + input: "compute_loss/concat_69" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_26_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/concat_72" + input: "train_op/gradients/compute_loss/MatMul_27_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_26_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_26_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_26_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_26_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_26_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_26_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_26_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_26_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_26_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_26_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_26_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_18_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\004\000\000\000@\000\000\000\320\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_18_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/MatMul_27_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Reshape_18_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_89_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_89_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_89/axis" + input: "train_op/gradients/compute_loss/concat_89_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_89_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_89_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_89_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_89_grad/mod" + input: "train_op/gradients/compute_loss/concat_89_grad/Shape" + input: "train_op/gradients/compute_loss/concat_89_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_89_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_33_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_89_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_89_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_89_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_33_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_89_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_89_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_89_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_89_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_89_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_89_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_89_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_89_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_89_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_89_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_89_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_89_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_89_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_22_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_22_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/Reshape_23_grad/Reshape" + input: "train_op/gradients/compute_loss/Reshape_22_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_106_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_106_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_106/axis" + input: "train_op/gradients/compute_loss/concat_106_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_106_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_106_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_106_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_106_grad/mod" + input: "train_op/gradients/compute_loss/concat_106_grad/Shape" + input: "train_op/gradients/compute_loss/concat_106_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_106_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_107_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_106_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_106_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_106_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_107_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_106_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_106_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_106_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_106_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_106_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_106_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_106_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_106_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_106_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_106_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_106_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_106_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_106_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_108_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_108_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_108/axis" + input: "train_op/gradients/compute_loss/concat_108_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_108_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_108_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_108_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_108_grad/mod" + input: "train_op/gradients/compute_loss/concat_108_grad/Shape" + input: "train_op/gradients/compute_loss/concat_108_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_108_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_27_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_108_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_108_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_108_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_27_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_108_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_108_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_108_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_108_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_108_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_108_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_108_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_108_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_108_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_108_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_108_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_108_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_108_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_13_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\003\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_13_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/concat_126_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Squeeze_13_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_60_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_60_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/concat_126_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/ExpandDims_60_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_38_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_38_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000@\003\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_38_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/mul_38_grad/Shape" + input: "train_op/gradients/compute_loss/mul_38_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_38_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_128_grad/tuple/control_dependency" + input: "compute_loss/Reshape_30" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_38_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/mul_38_grad/Mul" + input: "train_op/gradients/compute_loss/mul_38_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_38_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_38_grad/Sum" + input: "train_op/gradients/compute_loss/mul_38_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_38_grad/Mul_1" + op: "Mul" + input: "compute_loss/MatMul_46" + input: "train_op/gradients/compute_loss/concat_128_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_38_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/mul_38_grad/Mul_1" + input: "train_op/gradients/compute_loss/mul_38_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_38_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_38_grad/Sum_1" + input: "train_op/gradients/compute_loss/mul_38_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_38_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/mul_38_grad/Reshape" + input: "^train_op/gradients/compute_loss/mul_38_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/mul_38_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_38_grad/Reshape" + input: "^train_op/gradients/compute_loss/mul_38_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_38_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_38_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_38_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/mul_38_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_38_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 832 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_50_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/Squeeze_15_grad/Reshape" + input: "compute_loss/concat_135" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_50_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/MatMul_49" + input: "train_op/gradients/compute_loss/Squeeze_15_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_50_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_50_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_50_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_50_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_50_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_50_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_50_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_50_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_50_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_50_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_50_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_49_grad/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: "train_op/gradients/compute_loss/Slice_49_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_49_grad/stack/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: "train_op/gradients/compute_loss/Slice_49_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_49_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_49_grad/stack/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: "train_op/gradients/compute_loss/Slice_49_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_49/begin" + input: "train_op/gradients/compute_loss/Slice_49_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_49_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_49_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_49_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_49_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_49_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_49_grad/sub" + input: "compute_loss/Slice_49/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_49_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_49_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_49_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_49_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_49_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_49_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_49_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_49_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_49_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/ExpandDims_70_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_49_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_35_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_35_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_43_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Reshape_35_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_85" + op: "AddN" + input: "train_op/gradients/compute_loss/add_6_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/add_7_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/add_6_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_6_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_6_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_6_grad/stack/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: "train_op/gradients/compute_loss/Slice_6_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_6_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_6_grad/stack/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: "train_op/gradients/compute_loss/Slice_6_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_6/begin" + input: "train_op/gradients/compute_loss/Slice_6_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_6_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_6_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_6_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_6_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_6_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_6_grad/sub" + input: "compute_loss/Slice_6/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_6_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_6_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_6_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_6_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_6_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_6_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_6_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_6_grad/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: 3 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_6_grad/Pad" + op: "Pad" + input: "train_op/gradients/AddN_85" + input: "train_op/gradients/compute_loss/Slice_6_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_86" + op: "AddN" + input: "train_op/gradients/compute_loss/Slice_11_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_12_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_13_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Slice_11_grad/Pad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_13_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/AddN_86" + input: "compute_loss/Reshape_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_13_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/MatMul_12" + input: "train_op/gradients/AddN_86" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_13_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_13_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_13_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_13_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_13_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_13_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_13_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_13_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_13_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_13_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_13_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_19_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/MatMul_20_grad/tuple/control_dependency" + input: "compute_loss/concat_51" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_19_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/concat_54" + input: "train_op/gradients/compute_loss/MatMul_20_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_19_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_19_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_19_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_19_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_19_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_19_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_19_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_19_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_19_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_19_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_19_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_13_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\004\000\000\000@\000\000\000\320\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_13_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/MatMul_20_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_69_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_69_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_69/axis" + input: "train_op/gradients/compute_loss/concat_69_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_69_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_69_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_69_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_69_grad/mod" + input: "train_op/gradients/compute_loss/concat_69_grad/Shape" + input: "train_op/gradients/compute_loss/concat_69_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_69_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_26_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_69_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_69_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_69_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_26_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_69_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_69_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_69_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_69_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_69_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_69_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_69_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_69_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_69_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_69_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_69_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_69_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_69_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_17_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_17_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/Reshape_18_grad/Reshape" + input: "train_op/gradients/compute_loss/Reshape_17_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_88_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_88_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_88/axis" + input: "train_op/gradients/compute_loss/concat_88_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_88_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_88_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_88_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_88_grad/mod" + input: "train_op/gradients/compute_loss/concat_88_grad/Shape" + input: "train_op/gradients/compute_loss/concat_88_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_88_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_89_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_88_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_88_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_88_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_89_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_88_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_88_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_88_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_88_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_88_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_88_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_88_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_88_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_88_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_88_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_88_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_88_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_88_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_90_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_90_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_90/axis" + input: "train_op/gradients/compute_loss/concat_90_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_90_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_90_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_90_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_90_grad/mod" + input: "train_op/gradients/compute_loss/concat_90_grad/Shape" + input: "train_op/gradients/compute_loss/concat_90_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_90_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_22_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_90_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_90_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_90_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_22_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_90_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_90_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_90_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_90_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_90_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_90_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_90_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_90_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_90_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_90_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_90_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_90_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_90_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_11_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\003\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_11_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/concat_106_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Squeeze_11_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_50_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_50_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/concat_106_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/ExpandDims_50_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_32_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_32_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_32_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/mul_32_grad/Shape" + input: "train_op/gradients/compute_loss/mul_32_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_32_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_108_grad/tuple/control_dependency" + input: "compute_loss/Reshape_25" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_32_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/mul_32_grad/Mul" + input: "train_op/gradients/compute_loss/mul_32_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_32_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_32_grad/Sum" + input: "train_op/gradients/compute_loss/mul_32_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_32_grad/Mul_1" + op: "Mul" + input: "compute_loss/MatMul_39" + input: "train_op/gradients/compute_loss/concat_108_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_32_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/mul_32_grad/Mul_1" + input: "train_op/gradients/compute_loss/mul_32_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_32_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_32_grad/Sum_1" + input: "train_op/gradients/compute_loss/mul_32_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_32_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/mul_32_grad/Reshape" + input: "^train_op/gradients/compute_loss/mul_32_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/mul_32_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_32_grad/Reshape" + input: "^train_op/gradients/compute_loss/mul_32_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_32_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_32_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_32_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/mul_32_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_32_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_43_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/Squeeze_13_grad/Reshape" + input: "compute_loss/concat_117" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_43_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/MatMul_42" + input: "train_op/gradients/compute_loss/Squeeze_13_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_43_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_43_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_43_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_43_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_43_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_43_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_43_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_43_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_43_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_43_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_43_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_42_grad/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: "train_op/gradients/compute_loss/Slice_42_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_42_grad/stack/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: "train_op/gradients/compute_loss/Slice_42_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_42_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_42_grad/stack/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: "train_op/gradients/compute_loss/Slice_42_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_42/begin" + input: "train_op/gradients/compute_loss/Slice_42_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_42_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_42_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_42_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_42_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_42_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_42_grad/sub" + input: "compute_loss/Slice_42/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_42_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_42_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_42_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_42_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_42_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_42_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_42_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_42_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_42_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/ExpandDims_60_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_42_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_30_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_30_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_38_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Reshape_30_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_49_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/MatMul_50_grad/tuple/control_dependency" + input: "compute_loss/concat_139" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_49_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/concat_143" + input: "train_op/gradients/compute_loss/MatMul_50_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_49_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_49_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_49_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_49_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_49_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_49_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_49_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_49_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_49_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_49_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_49_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_135_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_135_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_135/axis" + input: "train_op/gradients/compute_loss/concat_135_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_135_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_135_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_135_grad/Shape_2" + op: "Shape" + input: "compute_loss/concat_134" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_135_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_132" + input: "compute_loss/concat_133" + input: "compute_loss/concat_134" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_135_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_135_grad/mod" + input: "train_op/gradients/compute_loss/concat_135_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_135_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_135_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_135_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_50_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_135_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_135_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_135_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_50_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_135_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_135_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_135_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_50_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_135_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_135_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_135_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_135_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_135_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_135_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_135_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_135_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_135_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_135_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_135_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_135_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_135_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_135_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_135_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_135_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_135_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_135_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_14_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_14_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/Reshape_35_grad/Reshape" + input: "train_op/gradients/compute_loss/Squeeze_14_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_87" + op: "AddN" + input: "train_op/gradients/compute_loss/Slice_4_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_5_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_6_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Slice_4_grad/Pad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_6_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/AddN_87" + input: "compute_loss/Reshape_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_6_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/MatMul_5" + input: "train_op/gradients/AddN_87" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_6_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_6_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_6_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_6_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_6_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_6_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_6_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_6_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_6_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_12_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/MatMul_13_grad/tuple/control_dependency" + input: "compute_loss/concat_31" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_12_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/concat_34" + input: "train_op/gradients/compute_loss/MatMul_13_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_12_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_12_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_12_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_12_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_12_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_12_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_12_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_12_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_12_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_12_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_12_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_8_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\200\000\000\000\240\001\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_8_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/MatMul_13_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_51_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_51_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_51/axis" + input: "train_op/gradients/compute_loss/concat_51_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_51_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_51_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_51_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_51_grad/mod" + input: "train_op/gradients/compute_loss/concat_51_grad/Shape" + input: "train_op/gradients/compute_loss/concat_51_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_51_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_19_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_51_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_51_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_51_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_19_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_51_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_51_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_51_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_51_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_51_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_51_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_51_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_51_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_51_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_51_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_51_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_51_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_51_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_12_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_12_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/Reshape_13_grad/Reshape" + input: "train_op/gradients/compute_loss/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_68_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_68_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_68/axis" + input: "train_op/gradients/compute_loss/concat_68_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_68_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_68_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_68_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_68_grad/mod" + input: "train_op/gradients/compute_loss/concat_68_grad/Shape" + input: "train_op/gradients/compute_loss/concat_68_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_68_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_69_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_68_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_68_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_68_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_69_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_68_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_68_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_68_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_68_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_68_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_68_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_68_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_68_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_68_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_68_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_68_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_68_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_68_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_70_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_70_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_70/axis" + input: "train_op/gradients/compute_loss/concat_70_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_70_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_70_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_70_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_70_grad/mod" + input: "train_op/gradients/compute_loss/concat_70_grad/Shape" + input: "train_op/gradients/compute_loss/concat_70_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_70_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_17_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_70_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_70_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_70_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_17_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_70_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_70_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_70_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_70_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_70_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_70_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_70_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_70_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_70_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_70_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_70_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_70_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_70_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_9_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\003\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_9_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/concat_88_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Squeeze_9_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_40_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_40_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/concat_88_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/ExpandDims_40_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_27_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_27_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\r\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_27_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/mul_27_grad/Shape" + input: "train_op/gradients/compute_loss/mul_27_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_27_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_90_grad/tuple/control_dependency" + input: "compute_loss/Reshape_20" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_27_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/mul_27_grad/Mul" + input: "train_op/gradients/compute_loss/mul_27_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_27_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_27_grad/Sum" + input: "train_op/gradients/compute_loss/mul_27_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_27_grad/Mul_1" + op: "Mul" + input: "compute_loss/MatMul_32" + input: "train_op/gradients/compute_loss/concat_90_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_27_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/mul_27_grad/Mul_1" + input: "train_op/gradients/compute_loss/mul_27_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_27_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_27_grad/Sum_1" + input: "train_op/gradients/compute_loss/mul_27_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_27_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/mul_27_grad/Reshape" + input: "^train_op/gradients/compute_loss/mul_27_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/mul_27_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_27_grad/Reshape" + input: "^train_op/gradients/compute_loss/mul_27_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_27_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_27_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_27_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/mul_27_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_27_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3328 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_36_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/Squeeze_11_grad/Reshape" + input: "compute_loss/concat_97" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_36_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/MatMul_35" + input: "train_op/gradients/compute_loss/Squeeze_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_36_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_36_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_36_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_36_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_36_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_36_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_36_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_36_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_36_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_36_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_36_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_35_grad/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: "train_op/gradients/compute_loss/Slice_35_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_35_grad/stack/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: "train_op/gradients/compute_loss/Slice_35_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_35_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_35_grad/stack/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: "train_op/gradients/compute_loss/Slice_35_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_35/begin" + input: "train_op/gradients/compute_loss/Slice_35_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_35_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_35_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_35_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_35_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_35_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_35_grad/sub" + input: "compute_loss/Slice_35/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_35_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_35_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_35_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_35_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_35_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_35_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_35_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_35_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_35_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/ExpandDims_50_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_35_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_25_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_25_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_32_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Reshape_25_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_42_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/MatMul_43_grad/tuple/control_dependency" + input: "compute_loss/concat_121" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_42_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/concat_125" + input: "train_op/gradients/compute_loss/MatMul_43_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_42_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_42_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_42_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_42_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_42_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_42_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_42_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_42_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_42_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_42_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_42_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_117_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_117_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_117/axis" + input: "train_op/gradients/compute_loss/concat_117_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_117_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_117_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_117_grad/Shape_2" + op: "Shape" + input: "compute_loss/concat_116" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_117_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_114" + input: "compute_loss/concat_115" + input: "compute_loss/concat_116" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_117_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_117_grad/mod" + input: "train_op/gradients/compute_loss/concat_117_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_117_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_117_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_117_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_43_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_117_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_117_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_117_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_43_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_117_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_117_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_117_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_43_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_117_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_117_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_117_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_117_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_117_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_117_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_117_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_117_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_117_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_117_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_117_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_117_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_117_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_117_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_117_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_117_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_117_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_117_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_12_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_12_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/Reshape_30_grad/Reshape" + input: "train_op/gradients/compute_loss/Squeeze_12_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_143_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_143_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_143/axis" + input: "train_op/gradients/compute_loss/concat_143_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_143_grad/Shape" + op: "Shape" + input: "compute_loss/concat_140" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_143_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_140" + input: "compute_loss/concat_141" + input: "compute_loss/concat_142" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_143_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_143_grad/mod" + input: "train_op/gradients/compute_loss/concat_143_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_143_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_143_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_143_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_49_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_143_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_143_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_143_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_49_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_143_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_143_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_143_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_49_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_143_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_143_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_143_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_143_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_143_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_143_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_143_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_143_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_143_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_143_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_143_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_143_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_143_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_143_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_143_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_143_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_143_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_143_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_139_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_139_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_139/axis" + input: "train_op/gradients/compute_loss/concat_139_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_139_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_139_grad/Shape_1" + op: "Shape" + input: "compute_loss/concat_137" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_139_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_136" + input: "compute_loss/concat_137" + input: "compute_loss/concat_138" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_139_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_139_grad/mod" + input: "train_op/gradients/compute_loss/concat_139_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_139_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_139_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_139_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_49_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_139_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_139_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_139_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_49_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_139_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_139_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_139_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_49_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_139_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_139_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_139_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_139_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_139_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_139_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_139_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_139_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_139_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_139_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_139_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_139_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_139_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_139_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_139_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_139_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_139_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_139_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_132_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_132_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_132/axis" + input: "train_op/gradients/compute_loss/concat_132_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_132_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_132_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_132_grad/Shape_2" + op: "Shape" + input: "compute_loss/zeros_14" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_132_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Cos_21" + input: "compute_loss/Neg_21" + input: "compute_loss/zeros_14" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_132_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_132_grad/mod" + input: "train_op/gradients/compute_loss/concat_132_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_132_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_132_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_132_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_135_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_132_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_132_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_132_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_135_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_132_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_132_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_132_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_135_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_132_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_132_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_132_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_132_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_132_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_132_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_132_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_132_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_132_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_132_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_132_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_132_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_132_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_132_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_132_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_132_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_132_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_132_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_133_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_133_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_133/axis" + input: "train_op/gradients/compute_loss/concat_133_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_133_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_133_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_133_grad/Shape_2" + op: "Shape" + input: "compute_loss/zeros_14" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_133_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Sin_21" + input: "compute_loss/Cos_21" + input: "compute_loss/zeros_14" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_133_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_133_grad/mod" + input: "train_op/gradients/compute_loss/concat_133_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_133_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_133_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_133_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_135_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_133_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_133_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_133_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_135_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_133_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_133_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_133_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_135_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_133_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_133_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_133_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_133_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_133_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_133_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_133_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_133_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_133_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_133_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_133_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_133_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_133_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_133_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_133_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_133_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_133_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_133_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_5_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/MatMul_6_grad/tuple/control_dependency" + input: "compute_loss/concat_13" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_5_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/concat_16" + input: "train_op/gradients/compute_loss/MatMul_6_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_5_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_5_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_5_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_5_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_5_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_5_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_3_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\200\000\000\000\240\001\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_3_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/MatMul_6_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_31_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_31_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_31/axis" + input: "train_op/gradients/compute_loss/concat_31_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_31_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_31_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_31_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_31_grad/mod" + input: "train_op/gradients/compute_loss/concat_31_grad/Shape" + input: "train_op/gradients/compute_loss/concat_31_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_31_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_12_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_31_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_31_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_31_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_12_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_31_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_31_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_31_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_31_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_31_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_31_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_31_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_31_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_31_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_31_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_31_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_31_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_31_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_7_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_7_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/Reshape_8_grad/Reshape" + input: "train_op/gradients/compute_loss/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_50_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_50_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_50/axis" + input: "train_op/gradients/compute_loss/concat_50_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_50_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_50_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_50_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_50_grad/mod" + input: "train_op/gradients/compute_loss/concat_50_grad/Shape" + input: "train_op/gradients/compute_loss/concat_50_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_50_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_51_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_50_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_50_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_50_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_51_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_50_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_50_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_50_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_50_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_50_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_50_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_50_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_50_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_50_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_50_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_50_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_50_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_50_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_52_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_52_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_52/axis" + input: "train_op/gradients/compute_loss/concat_52_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_52_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_52_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_52_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_52_grad/mod" + input: "train_op/gradients/compute_loss/concat_52_grad/Shape" + input: "train_op/gradients/compute_loss/concat_52_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_52_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_12_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_52_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_52_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_52_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_12_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_52_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_52_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_52_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_52_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_52_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_52_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_52_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_52_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_52_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_52_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_52_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_52_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_52_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_7_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\003\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_7_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/concat_68_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Squeeze_7_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_30_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_30_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/concat_68_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/ExpandDims_30_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_21_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_21_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_21_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/mul_21_grad/Shape" + input: "train_op/gradients/compute_loss/mul_21_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_21_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_70_grad/tuple/control_dependency" + input: "compute_loss/Reshape_15" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_21_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/mul_21_grad/Mul" + input: "train_op/gradients/compute_loss/mul_21_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_21_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_21_grad/Sum" + input: "train_op/gradients/compute_loss/mul_21_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_21_grad/Mul_1" + op: "Mul" + input: "compute_loss/MatMul_25" + input: "train_op/gradients/compute_loss/concat_70_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_21_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/mul_21_grad/Mul_1" + input: "train_op/gradients/compute_loss/mul_21_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_21_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_21_grad/Sum_1" + input: "train_op/gradients/compute_loss/mul_21_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_21_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/mul_21_grad/Reshape" + input: "^train_op/gradients/compute_loss/mul_21_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/mul_21_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_21_grad/Reshape" + input: "^train_op/gradients/compute_loss/mul_21_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_21_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_21_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_21_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/mul_21_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_21_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_29_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/Squeeze_9_grad/Reshape" + input: "compute_loss/concat_79" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_29_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/MatMul_28" + input: "train_op/gradients/compute_loss/Squeeze_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_29_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_29_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_29_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_29_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_29_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_29_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_29_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_29_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_29_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_29_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_29_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_28_grad/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: "train_op/gradients/compute_loss/Slice_28_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_28_grad/stack/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: "train_op/gradients/compute_loss/Slice_28_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_28_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_28_grad/stack/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: "train_op/gradients/compute_loss/Slice_28_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_28/begin" + input: "train_op/gradients/compute_loss/Slice_28_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_28_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_28_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_28_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_28_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_28_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_28_grad/sub" + input: "compute_loss/Slice_28/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_28_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_28_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_28_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_28_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_28_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_28_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_28_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_28_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_28_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/ExpandDims_40_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_28_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_20_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_20_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_27_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Reshape_20_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_35_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/MatMul_36_grad/tuple/control_dependency" + input: "compute_loss/concat_101" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_35_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/concat_105" + input: "train_op/gradients/compute_loss/MatMul_36_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_35_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_35_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_35_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_35_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_35_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_35_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_35_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_35_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_35_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_35_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_35_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_97_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_97_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_97/axis" + input: "train_op/gradients/compute_loss/concat_97_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_97_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_97_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_97_grad/Shape_2" + op: "Shape" + input: "compute_loss/concat_96" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_97_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_94" + input: "compute_loss/concat_95" + input: "compute_loss/concat_96" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_97_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_97_grad/mod" + input: "train_op/gradients/compute_loss/concat_97_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_97_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_97_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_97_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_36_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_97_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_97_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_97_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_36_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_97_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_97_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_97_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_36_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_97_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_97_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_97_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_97_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_97_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_97_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_97_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_97_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_97_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_97_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_97_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_97_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_97_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_97_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_97_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_97_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_97_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_97_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_10_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_10_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/Reshape_25_grad/Reshape" + input: "train_op/gradients/compute_loss/Squeeze_10_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_125_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_125_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_125/axis" + input: "train_op/gradients/compute_loss/concat_125_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_125_grad/Shape" + op: "Shape" + input: "compute_loss/concat_122" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_125_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_122" + input: "compute_loss/concat_123" + input: "compute_loss/concat_124" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_125_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_125_grad/mod" + input: "train_op/gradients/compute_loss/concat_125_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_125_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_125_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_125_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_42_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_125_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_125_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_125_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_42_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_125_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_125_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_125_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_42_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_125_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_125_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_125_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_125_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_125_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_125_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_125_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_125_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_125_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_125_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_125_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_125_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_125_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_125_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_125_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_125_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_125_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_125_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_121_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_121_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_121/axis" + input: "train_op/gradients/compute_loss/concat_121_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_121_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_121_grad/Shape_1" + op: "Shape" + input: "compute_loss/concat_119" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_121_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_118" + input: "compute_loss/concat_119" + input: "compute_loss/concat_120" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_121_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_121_grad/mod" + input: "train_op/gradients/compute_loss/concat_121_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_121_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_121_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_121_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_42_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_121_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_121_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_121_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_42_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_121_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_121_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_121_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_42_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_121_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_121_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_121_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_121_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_121_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_121_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_121_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_121_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_121_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_121_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_121_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_121_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_121_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_121_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_121_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_121_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_121_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_121_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_114_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_114_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_114/axis" + input: "train_op/gradients/compute_loss/concat_114_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_114_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_114_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_114_grad/Shape_2" + op: "Shape" + input: "compute_loss/zeros_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_114_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Cos_18" + input: "compute_loss/Neg_18" + input: "compute_loss/zeros_12" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_114_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_114_grad/mod" + input: "train_op/gradients/compute_loss/concat_114_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_114_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_114_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_114_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_117_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_114_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_114_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_114_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_117_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_114_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_114_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_114_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_117_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_114_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_114_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_114_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_114_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_114_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_114_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_114_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_114_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_114_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_114_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_114_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_114_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_114_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_114_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_114_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_114_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_114_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_114_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_115_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_115_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_115/axis" + input: "train_op/gradients/compute_loss/concat_115_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_115_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_115_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_115_grad/Shape_2" + op: "Shape" + input: "compute_loss/zeros_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_115_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Sin_18" + input: "compute_loss/Cos_18" + input: "compute_loss/zeros_12" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_115_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_115_grad/mod" + input: "train_op/gradients/compute_loss/concat_115_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_115_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_115_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_115_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_117_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_115_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_115_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_115_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_117_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_115_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_115_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_115_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_117_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_115_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_115_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_115_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_115_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_115_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_115_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_115_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_115_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_115_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_115_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_115_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_115_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_115_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_115_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_115_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_115_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_115_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_115_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_88" + op: "AddN" + input: "train_op/gradients/compute_loss/Squeeze_14_grad/Reshape" + input: "train_op/gradients/compute_loss/Squeeze_12_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Squeeze_14_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_3_grad/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: "train_op/gradients/depth_prediction/truediv_3_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/depth_prediction/truediv_3_grad/Shape" + input: "train_op/gradients/depth_prediction/truediv_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_3_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/AddN_88" + input: "depth_prediction/depth_net/add" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_3_grad/Sum" + op: "Sum" + input: "train_op/gradients/depth_prediction/truediv_3_grad/RealDiv" + input: "train_op/gradients/depth_prediction/truediv_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_3_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/depth_prediction/truediv_3_grad/Sum" + input: "train_op/gradients/depth_prediction/truediv_3_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_3_grad/Neg" + op: "Neg" + input: "depth_prediction/truediv_3/x" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_3_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/depth_prediction/truediv_3_grad/Neg" + input: "depth_prediction/depth_net/add" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_3_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/depth_prediction/truediv_3_grad/RealDiv_1" + input: "depth_prediction/depth_net/add" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_3_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_88" + input: "train_op/gradients/depth_prediction/truediv_3_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_3_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/depth_prediction/truediv_3_grad/mul" + input: "train_op/gradients/depth_prediction/truediv_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_3_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/depth_prediction/truediv_3_grad/Sum_1" + input: "train_op/gradients/depth_prediction/truediv_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/truediv_3_grad/Reshape" + input: "^train_op/gradients/depth_prediction/truediv_3_grad/Reshape_1" +} +node { + name: "train_op/gradients/depth_prediction/truediv_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/truediv_3_grad/Reshape" + input: "^train_op/gradients/depth_prediction/truediv_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/truediv_3_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/truediv_3_grad/Reshape_1" + input: "^train_op/gradients/depth_prediction/truediv_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/truediv_3_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_141_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_141_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_141/axis" + input: "train_op/gradients/compute_loss/concat_141_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_141_grad/Shape" + op: "Shape" + input: "compute_loss/zeros_14" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_141_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/zeros_14" + input: "compute_loss/Cos_23" + input: "compute_loss/Neg_23" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_141_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_141_grad/mod" + input: "train_op/gradients/compute_loss/concat_141_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_141_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_141_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_141_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_143_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_141_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_141_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_141_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_143_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_141_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_141_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_141_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_143_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_141_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_141_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_141_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_141_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_141_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_141_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_141_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_141_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_141_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_141_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_141_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_141_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_141_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_141_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_141_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_141_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_141_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_141_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_142_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_142_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_142/axis" + input: "train_op/gradients/compute_loss/concat_142_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_142_grad/Shape" + op: "Shape" + input: "compute_loss/zeros_14" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_142_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/zeros_14" + input: "compute_loss/Sin_23" + input: "compute_loss/Cos_23" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_142_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_142_grad/mod" + input: "train_op/gradients/compute_loss/concat_142_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_142_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_142_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_142_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_143_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_142_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_142_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_142_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_143_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_142_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_142_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_142_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_143_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_142_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_142_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_142_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_142_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_142_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_142_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_142_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_142_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_142_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_142_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_142_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_142_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_142_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_142_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_142_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_142_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_142_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_142_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_136_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_136_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_136/axis" + input: "train_op/gradients/compute_loss/concat_136_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_136_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_136_grad/Shape_1" + op: "Shape" + input: "compute_loss/zeros_14" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_136_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Cos_22" + input: "compute_loss/zeros_14" + input: "compute_loss/Sin_22" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_136_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_136_grad/mod" + input: "train_op/gradients/compute_loss/concat_136_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_136_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_136_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_136_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_139_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_136_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_136_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_136_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_139_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_136_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_136_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_136_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_139_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_136_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_136_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_136_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_136_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_136_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_136_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_136_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_136_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_136_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_136_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_136_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_136_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_136_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_136_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_136_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_136_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_136_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_136_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_138_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_138_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_138/axis" + input: "train_op/gradients/compute_loss/concat_138_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_138_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_138_grad/Shape_1" + op: "Shape" + input: "compute_loss/zeros_14" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_138_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Neg_22" + input: "compute_loss/zeros_14" + input: "compute_loss/Cos_22" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_138_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_138_grad/mod" + input: "train_op/gradients/compute_loss/concat_138_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_138_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_138_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_138_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_139_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_138_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_138_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_138_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_139_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_138_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_138_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_138_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_139_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_138_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_138_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_138_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_138_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_138_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_138_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_138_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_138_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_138_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_138_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_138_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_138_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_138_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_138_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_138_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_138_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_138_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_138_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_21_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_132_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_89" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_132_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_133_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_132_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_21_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_89" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_21_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_72" + input: "^train_op/gradients/AddN_89" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_21_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_21_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_21_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_13_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_13_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_13/axis" + input: "train_op/gradients/compute_loss/concat_13_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_13_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_13_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_13_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_13_grad/mod" + input: "train_op/gradients/compute_loss/concat_13_grad/Shape" + input: "train_op/gradients/compute_loss/concat_13_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_13_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_5_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_13_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_13_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_13_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_5_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_13_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_13_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_13_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_13_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_13_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_13_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_13_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_13_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_13_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_13_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_13_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_13_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_13_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_2_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_2_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/Reshape_3_grad/Reshape" + input: "train_op/gradients/compute_loss/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_30_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_30_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_30/axis" + input: "train_op/gradients/compute_loss/concat_30_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_30_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_30_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_30_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_30_grad/mod" + input: "train_op/gradients/compute_loss/concat_30_grad/Shape" + input: "train_op/gradients/compute_loss/concat_30_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_30_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_31_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_30_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_30_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_30_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_31_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_30_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_30_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_30_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_30_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_30_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_30_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_30_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_30_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_30_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_30_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_30_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_30_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_30_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_32_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_32_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_32/axis" + input: "train_op/gradients/compute_loss/concat_32_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_32_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_32_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_32_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_32_grad/mod" + input: "train_op/gradients/compute_loss/concat_32_grad/Shape" + input: "train_op/gradients/compute_loss/concat_32_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_32_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_7_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_32_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_32_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_32_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_7_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_32_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_32_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_32_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_32_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_32_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_32_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_32_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_32_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_32_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_32_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_32_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_32_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_32_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_5_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\003\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_5_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/concat_50_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Squeeze_5_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_20_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_20_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/concat_50_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/ExpandDims_20_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_16_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_16_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\0004\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_16_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/mul_16_grad/Shape" + input: "train_op/gradients/compute_loss/mul_16_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_16_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_52_grad/tuple/control_dependency" + input: "compute_loss/Reshape_10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_16_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/mul_16_grad/Mul" + input: "train_op/gradients/compute_loss/mul_16_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_16_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_16_grad/Sum" + input: "train_op/gradients/compute_loss/mul_16_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_16_grad/Mul_1" + op: "Mul" + input: "compute_loss/MatMul_18" + input: "train_op/gradients/compute_loss/concat_52_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_16_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/mul_16_grad/Mul_1" + input: "train_op/gradients/compute_loss/mul_16_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_16_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_16_grad/Sum_1" + input: "train_op/gradients/compute_loss/mul_16_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_16_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/mul_16_grad/Reshape" + input: "^train_op/gradients/compute_loss/mul_16_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/mul_16_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_16_grad/Reshape" + input: "^train_op/gradients/compute_loss/mul_16_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_16_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_16_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_16_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/mul_16_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_16_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 13312 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_22_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/Squeeze_7_grad/Reshape" + input: "compute_loss/concat_59" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_22_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/MatMul_21" + input: "train_op/gradients/compute_loss/Squeeze_7_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_22_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_22_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_22_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_22_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_22_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_22_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_22_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_22_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_22_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_22_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_22_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_21_grad/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: "train_op/gradients/compute_loss/Slice_21_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_21_grad/stack/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: "train_op/gradients/compute_loss/Slice_21_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_21_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_21_grad/stack/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: "train_op/gradients/compute_loss/Slice_21_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_21/begin" + input: "train_op/gradients/compute_loss/Slice_21_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_21_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_21_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_21_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_21_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_21_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_21_grad/sub" + input: "compute_loss/Slice_21/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_21_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_21_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_21_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_21_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_21_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_21_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_21_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_21_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_21_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/ExpandDims_30_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_21_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_15_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_15_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_21_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Reshape_15_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_28_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/MatMul_29_grad/tuple/control_dependency" + input: "compute_loss/concat_83" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_28_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/concat_87" + input: "train_op/gradients/compute_loss/MatMul_29_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_28_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_28_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_28_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_28_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_28_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_28_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_28_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_28_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_28_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_28_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_28_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_79_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_79_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_79/axis" + input: "train_op/gradients/compute_loss/concat_79_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_79_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_79_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_79_grad/Shape_2" + op: "Shape" + input: "compute_loss/concat_78" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_79_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_76" + input: "compute_loss/concat_77" + input: "compute_loss/concat_78" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_79_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_79_grad/mod" + input: "train_op/gradients/compute_loss/concat_79_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_79_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_79_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_79_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_29_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_79_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_79_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_79_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_29_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_79_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_79_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_79_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_29_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_79_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_79_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_79_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_79_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_79_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_79_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_79_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_79_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_79_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_79_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_79_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_79_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_79_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_79_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_79_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_79_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_79_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_79_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_8_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_8_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/Reshape_20_grad/Reshape" + input: "train_op/gradients/compute_loss/Squeeze_8_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_105_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_105_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_105/axis" + input: "train_op/gradients/compute_loss/concat_105_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_105_grad/Shape" + op: "Shape" + input: "compute_loss/concat_102" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_105_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_102" + input: "compute_loss/concat_103" + input: "compute_loss/concat_104" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_105_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_105_grad/mod" + input: "train_op/gradients/compute_loss/concat_105_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_105_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_105_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_105_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_35_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_105_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_105_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_105_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_35_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_105_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_105_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_105_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_35_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_105_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_105_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_105_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_105_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_105_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_105_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_105_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_105_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_105_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_105_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_105_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_105_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_105_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_105_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_105_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_105_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_105_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_105_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_101_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_101_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_101/axis" + input: "train_op/gradients/compute_loss/concat_101_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_101_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_101_grad/Shape_1" + op: "Shape" + input: "compute_loss/concat_99" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_101_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_98" + input: "compute_loss/concat_99" + input: "compute_loss/concat_100" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_101_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_101_grad/mod" + input: "train_op/gradients/compute_loss/concat_101_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_101_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_101_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_101_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_35_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_101_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_101_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_101_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_35_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_101_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_101_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_101_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_35_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_101_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_101_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_101_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_101_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_101_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_101_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_101_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_101_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_101_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_101_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_101_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_101_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_101_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_101_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_101_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_101_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_101_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_101_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_94_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_94_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_94/axis" + input: "train_op/gradients/compute_loss/concat_94_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_94_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_94_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_94_grad/Shape_2" + op: "Shape" + input: "compute_loss/zeros_10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_94_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Cos_15" + input: "compute_loss/Neg_15" + input: "compute_loss/zeros_10" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_94_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_94_grad/mod" + input: "train_op/gradients/compute_loss/concat_94_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_94_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_94_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_94_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_97_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_94_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_94_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_94_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_97_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_94_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_94_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_94_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_97_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_94_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_94_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_94_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_94_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_94_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_94_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_94_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_94_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_94_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_94_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_94_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_94_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_94_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_94_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_94_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_94_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_94_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_94_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_95_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_95_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_95/axis" + input: "train_op/gradients/compute_loss/concat_95_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_95_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_95_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_95_grad/Shape_2" + op: "Shape" + input: "compute_loss/zeros_10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_95_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Sin_15" + input: "compute_loss/Cos_15" + input: "compute_loss/zeros_10" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_95_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_95_grad/mod" + input: "train_op/gradients/compute_loss/concat_95_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_95_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_95_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_95_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_97_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_95_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_95_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_95_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_97_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_95_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_95_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_95_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_97_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_95_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_95_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_95_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_95_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_95_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_95_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_95_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_95_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_95_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_95_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_95_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_95_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_95_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_95_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_95_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_95_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_95_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_95_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_123_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_123_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_123/axis" + input: "train_op/gradients/compute_loss/concat_123_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_123_grad/Shape" + op: "Shape" + input: "compute_loss/zeros_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_123_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/zeros_12" + input: "compute_loss/Cos_20" + input: "compute_loss/Neg_20" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_123_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_123_grad/mod" + input: "train_op/gradients/compute_loss/concat_123_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_123_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_123_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_123_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_125_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_123_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_123_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_123_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_125_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_123_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_123_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_123_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_125_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_123_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_123_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_123_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_123_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_123_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_123_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_123_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_123_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_123_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_123_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_123_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_123_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_123_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_123_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_123_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_123_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_123_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_123_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_124_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_124_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_124/axis" + input: "train_op/gradients/compute_loss/concat_124_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_124_grad/Shape" + op: "Shape" + input: "compute_loss/zeros_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_124_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/zeros_12" + input: "compute_loss/Sin_20" + input: "compute_loss/Cos_20" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_124_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_124_grad/mod" + input: "train_op/gradients/compute_loss/concat_124_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_124_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_124_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_124_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_125_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_124_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_124_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_124_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_125_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_124_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_124_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_124_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_125_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_124_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_124_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_124_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_124_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_124_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_124_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_124_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_124_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_124_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_124_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_124_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_124_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_124_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_124_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_124_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_124_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_124_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_124_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_118_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_118_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_118/axis" + input: "train_op/gradients/compute_loss/concat_118_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_118_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_118_grad/Shape_1" + op: "Shape" + input: "compute_loss/zeros_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_118_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Cos_19" + input: "compute_loss/zeros_12" + input: "compute_loss/Sin_19" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_118_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_118_grad/mod" + input: "train_op/gradients/compute_loss/concat_118_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_118_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_118_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_118_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_121_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_118_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_118_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_118_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_121_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_118_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_118_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_118_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_121_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_118_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_118_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_118_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_118_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_118_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_118_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_118_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_118_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_118_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_118_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_118_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_118_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_118_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_118_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_118_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_118_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_118_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_118_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_120_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_120_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_120/axis" + input: "train_op/gradients/compute_loss/concat_120_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_120_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_120_grad/Shape_1" + op: "Shape" + input: "compute_loss/zeros_12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_120_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Neg_19" + input: "compute_loss/zeros_12" + input: "compute_loss/Cos_19" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_120_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_120_grad/mod" + input: "train_op/gradients/compute_loss/concat_120_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_120_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_120_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_120_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_121_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_120_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_120_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_120_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_121_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_120_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_120_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_120_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_121_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_120_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_120_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_120_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_120_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_120_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_120_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_120_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_120_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_120_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_120_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_120_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_120_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_120_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_120_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_120_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_120_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_120_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_120_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_18_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_114_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_90" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_114_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_115_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_114_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_18_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_90" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_18_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_62" + input: "^train_op/gradients/AddN_90" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_18_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_18_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_18_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_23_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_141_grad/tuple/control_dependency_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_91" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_141_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_142_grad/tuple/control_dependency_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_141_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_23_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_91" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_23_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_76" + input: "^train_op/gradients/AddN_91" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_23_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_23_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_23_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_22_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_138_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_92" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_136_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_138_grad/tuple/control_dependency_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_136_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_22_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_92" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_22_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_74" + input: "^train_op/gradients/AddN_92" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_22_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_22_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_22_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_93" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_133_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Neg_21_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_133_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_21_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_72" + input: "^train_op/gradients/AddN_93" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_21_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_93" + input: "train_op/gradients/compute_loss/Sin_21_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_12_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_12_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_12/axis" + input: "train_op/gradients/compute_loss/concat_12_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_12_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_12_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_12_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_12_grad/mod" + input: "train_op/gradients/compute_loss/concat_12_grad/Shape" + input: "train_op/gradients/compute_loss/concat_12_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_12_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_13_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_12_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_12_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_12_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_13_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_12_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_12_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_12_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_12_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_12_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_12_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_12_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_12_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_12_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_12_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_12_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_12_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_12_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_14_grad/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: 3 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_14_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_14/axis" + input: "train_op/gradients/compute_loss/concat_14_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_14_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_14_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_14_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_14_grad/mod" + input: "train_op/gradients/compute_loss/concat_14_grad/Shape" + input: "train_op/gradients/compute_loss/concat_14_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + shape { + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_14_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_2_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_14_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_14_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_14_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/Reshape_2_grad/Reshape" + input: "train_op/gradients/compute_loss/concat_14_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_14_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_14_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_14_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_14_grad/Slice_1" +} +node { + name: "train_op/gradients/compute_loss/concat_14_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_14_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_14_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_14_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_14_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_14_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_14_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_14_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_3_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\003\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_3_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/concat_30_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Squeeze_3_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_10_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_10_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/concat_30_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/ExpandDims_10_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_10_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_10_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/mul_10_grad/Shape" + input: "train_op/gradients/compute_loss/mul_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_10_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_32_grad/tuple/control_dependency" + input: "compute_loss/Reshape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_10_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/mul_10_grad/Mul" + input: "train_op/gradients/compute_loss/mul_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_10_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_10_grad/Sum" + input: "train_op/gradients/compute_loss/mul_10_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_10_grad/Mul_1" + op: "Mul" + input: "compute_loss/MatMul_11" + input: "train_op/gradients/compute_loss/concat_32_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_10_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/mul_10_grad/Mul_1" + input: "train_op/gradients/compute_loss/mul_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_10_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_10_grad/Sum_1" + input: "train_op/gradients/compute_loss/mul_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_10_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/mul_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/mul_10_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/mul_10_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/mul_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_10_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_10_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_10_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/mul_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_10_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_15_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/Squeeze_5_grad/Reshape" + input: "compute_loss/concat_41" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_15_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/MatMul_14" + input: "train_op/gradients/compute_loss/Squeeze_5_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_15_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_15_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_15_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_15_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_15_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_15_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_15_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_15_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_15_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_15_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_15_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_14_grad/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: "train_op/gradients/compute_loss/Slice_14_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_14_grad/stack/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: "train_op/gradients/compute_loss/Slice_14_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_14_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_14_grad/stack/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: "train_op/gradients/compute_loss/Slice_14_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_14/begin" + input: "train_op/gradients/compute_loss/Slice_14_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_14_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_14_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_14_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_14_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_14_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_14_grad/sub" + input: "compute_loss/Slice_14/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_14_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_14_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_14_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_14_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_14_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_14_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_14_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_14_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_14_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/ExpandDims_20_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_14_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_10_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_10_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_16_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_21_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/MatMul_22_grad/tuple/control_dependency" + input: "compute_loss/concat_63" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_21_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/concat_67" + input: "train_op/gradients/compute_loss/MatMul_22_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_21_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_21_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_21_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_21_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_21_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_21_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_21_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_21_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_21_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_21_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_21_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_59_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_59_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_59/axis" + input: "train_op/gradients/compute_loss/concat_59_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_59_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_59_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_59_grad/Shape_2" + op: "Shape" + input: "compute_loss/concat_58" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_59_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_56" + input: "compute_loss/concat_57" + input: "compute_loss/concat_58" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_59_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_59_grad/mod" + input: "train_op/gradients/compute_loss/concat_59_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_59_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_59_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_59_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_22_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_59_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_59_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_59_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_22_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_59_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_59_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_59_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_22_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_59_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_59_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_59_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_59_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_59_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_59_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_59_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_59_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_59_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_59_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_59_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_59_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_59_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_59_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_59_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_59_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_59_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_59_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_6_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_6_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/Reshape_15_grad/Reshape" + input: "train_op/gradients/compute_loss/Squeeze_6_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_87_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_87_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_87/axis" + input: "train_op/gradients/compute_loss/concat_87_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_87_grad/Shape" + op: "Shape" + input: "compute_loss/concat_84" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_87_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_84" + input: "compute_loss/concat_85" + input: "compute_loss/concat_86" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_87_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_87_grad/mod" + input: "train_op/gradients/compute_loss/concat_87_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_87_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_87_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_87_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_28_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_87_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_87_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_87_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_28_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_87_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_87_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_87_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_28_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_87_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_87_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_87_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_87_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_87_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_87_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_87_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_87_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_87_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_87_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_87_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_87_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_87_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_87_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_87_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_87_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_87_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_87_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_83_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_83_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_83/axis" + input: "train_op/gradients/compute_loss/concat_83_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_83_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_83_grad/Shape_1" + op: "Shape" + input: "compute_loss/concat_81" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_83_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_80" + input: "compute_loss/concat_81" + input: "compute_loss/concat_82" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_83_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_83_grad/mod" + input: "train_op/gradients/compute_loss/concat_83_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_83_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_83_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_83_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_28_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_83_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_83_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_83_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_28_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_83_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_83_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_83_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_28_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_83_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_83_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_83_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_83_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_83_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_83_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_83_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_83_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_83_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_83_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_83_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_83_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_83_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_83_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_83_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_83_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_83_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_83_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_76_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_76_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_76/axis" + input: "train_op/gradients/compute_loss/concat_76_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_76_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_76_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_76_grad/Shape_2" + op: "Shape" + input: "compute_loss/zeros_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_76_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Cos_12" + input: "compute_loss/Neg_12" + input: "compute_loss/zeros_8" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_76_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_76_grad/mod" + input: "train_op/gradients/compute_loss/concat_76_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_76_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_76_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_76_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_79_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_76_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_76_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_76_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_79_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_76_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_76_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_76_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_79_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_76_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_76_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_76_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_76_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_76_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_76_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_76_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_76_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_76_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_76_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_76_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_76_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_76_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_76_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_76_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_76_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_76_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_76_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_77_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_77_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_77/axis" + input: "train_op/gradients/compute_loss/concat_77_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_77_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_77_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_77_grad/Shape_2" + op: "Shape" + input: "compute_loss/zeros_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_77_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Sin_12" + input: "compute_loss/Cos_12" + input: "compute_loss/zeros_8" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_77_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_77_grad/mod" + input: "train_op/gradients/compute_loss/concat_77_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_77_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_77_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_77_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_79_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_77_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_77_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_77_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_79_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_77_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_77_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_77_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_79_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_77_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_77_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_77_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_77_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_77_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_77_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_77_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_77_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_77_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_77_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_77_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_77_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_77_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_77_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_77_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_77_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_77_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_77_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_94" + op: "AddN" + input: "train_op/gradients/compute_loss/Squeeze_10_grad/Reshape" + input: "train_op/gradients/compute_loss/Squeeze_8_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Squeeze_10_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_2_grad/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: "train_op/gradients/depth_prediction/truediv_2_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/depth_prediction/truediv_2_grad/Shape" + input: "train_op/gradients/depth_prediction/truediv_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_2_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/AddN_94" + input: "depth_prediction/depth_net/add_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_2_grad/Sum" + op: "Sum" + input: "train_op/gradients/depth_prediction/truediv_2_grad/RealDiv" + input: "train_op/gradients/depth_prediction/truediv_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_2_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/depth_prediction/truediv_2_grad/Sum" + input: "train_op/gradients/depth_prediction/truediv_2_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_2_grad/Neg" + op: "Neg" + input: "depth_prediction/truediv_2/x" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_2_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/depth_prediction/truediv_2_grad/Neg" + input: "depth_prediction/depth_net/add_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_2_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/depth_prediction/truediv_2_grad/RealDiv_1" + input: "depth_prediction/depth_net/add_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_2_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_94" + input: "train_op/gradients/depth_prediction/truediv_2_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_2_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/depth_prediction/truediv_2_grad/mul" + input: "train_op/gradients/depth_prediction/truediv_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_2_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/depth_prediction/truediv_2_grad/Sum_1" + input: "train_op/gradients/depth_prediction/truediv_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/truediv_2_grad/Reshape" + input: "^train_op/gradients/depth_prediction/truediv_2_grad/Reshape_1" +} +node { + name: "train_op/gradients/depth_prediction/truediv_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/truediv_2_grad/Reshape" + input: "^train_op/gradients/depth_prediction/truediv_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/truediv_2_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/truediv_2_grad/Reshape_1" + input: "^train_op/gradients/depth_prediction/truediv_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/truediv_2_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_103_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_103_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_103/axis" + input: "train_op/gradients/compute_loss/concat_103_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_103_grad/Shape" + op: "Shape" + input: "compute_loss/zeros_10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_103_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/zeros_10" + input: "compute_loss/Cos_17" + input: "compute_loss/Neg_17" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_103_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_103_grad/mod" + input: "train_op/gradients/compute_loss/concat_103_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_103_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_103_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_103_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_105_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_103_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_103_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_103_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_105_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_103_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_103_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_103_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_105_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_103_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_103_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_103_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_103_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_103_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_103_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_103_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_103_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_103_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_103_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_103_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_103_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_103_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_103_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_103_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_103_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_103_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_103_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_104_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_104_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_104/axis" + input: "train_op/gradients/compute_loss/concat_104_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_104_grad/Shape" + op: "Shape" + input: "compute_loss/zeros_10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_104_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/zeros_10" + input: "compute_loss/Sin_17" + input: "compute_loss/Cos_17" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_104_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_104_grad/mod" + input: "train_op/gradients/compute_loss/concat_104_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_104_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_104_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_104_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_105_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_104_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_104_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_104_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_105_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_104_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_104_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_104_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_105_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_104_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_104_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_104_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_104_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_104_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_104_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_104_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_104_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_104_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_104_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_104_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_104_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_104_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_104_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_104_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_104_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_104_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_104_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_98_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_98_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_98/axis" + input: "train_op/gradients/compute_loss/concat_98_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_98_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_98_grad/Shape_1" + op: "Shape" + input: "compute_loss/zeros_10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_98_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Cos_16" + input: "compute_loss/zeros_10" + input: "compute_loss/Sin_16" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_98_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_98_grad/mod" + input: "train_op/gradients/compute_loss/concat_98_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_98_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_98_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_98_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_101_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_98_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_98_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_98_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_101_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_98_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_98_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_98_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_101_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_98_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_98_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_98_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_98_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_98_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_98_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_98_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_98_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_98_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_98_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_98_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_98_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_98_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_98_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_98_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_98_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_98_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_98_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_100_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_100_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_100/axis" + input: "train_op/gradients/compute_loss/concat_100_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_100_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_100_grad/Shape_1" + op: "Shape" + input: "compute_loss/zeros_10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_100_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Neg_16" + input: "compute_loss/zeros_10" + input: "compute_loss/Cos_16" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_100_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_100_grad/mod" + input: "train_op/gradients/compute_loss/concat_100_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_100_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_100_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_100_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_101_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_100_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_100_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_100_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_101_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_100_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_100_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_100_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_101_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_100_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_100_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_100_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_100_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_100_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_100_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_100_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_100_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_100_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_100_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_100_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_100_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_100_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_100_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_100_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_100_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_100_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_100_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_15_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_94_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_95" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_94_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_95_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_94_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_15_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_95" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_15_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_52" + input: "^train_op/gradients/AddN_95" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_15_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_15_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_15_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_20_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_123_grad/tuple/control_dependency_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_96" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_123_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_124_grad/tuple/control_dependency_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_123_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_20_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_96" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_20_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_66" + input: "^train_op/gradients/AddN_96" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_20_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_20_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_20_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_19_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_120_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_97" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_118_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_120_grad/tuple/control_dependency_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_118_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_19_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_97" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_19_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_64" + input: "^train_op/gradients/AddN_97" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_19_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_19_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_19_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_98" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_115_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Neg_18_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_115_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_18_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_62" + input: "^train_op/gradients/AddN_98" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_18_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_98" + input: "train_op/gradients/compute_loss/Sin_18_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_99" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_142_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Neg_23_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_142_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_23_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_76" + input: "^train_op/gradients/AddN_99" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_23_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_99" + input: "train_op/gradients/compute_loss/Sin_23_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_100" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_136_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/Neg_22_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_136_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_22_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_74" + input: "^train_op/gradients/AddN_100" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_22_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_100" + input: "train_op/gradients/compute_loss/Sin_22_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_101" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_21_grad/mul" + input: "train_op/gradients/compute_loss/Sin_21_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_21_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_72_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_72_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_101" + input: "train_op/gradients/compute_loss/ExpandDims_72_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\003\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/concat_12_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Squeeze_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/concat_12_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/ExpandDims_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_5_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\003\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_5_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\000\320\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/mul_5_grad/Shape" + input: "train_op/gradients/compute_loss/mul_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_5_grad/Mul" + op: "Mul" + input: "train_op/gradients/compute_loss/concat_14_grad/tuple/control_dependency" + input: "compute_loss/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_5_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/mul_5_grad/Mul" + input: "train_op/gradients/compute_loss/mul_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_5_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_5_grad/Sum" + input: "train_op/gradients/compute_loss/mul_5_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_5_grad/Mul_1" + op: "Mul" + input: "compute_loss/MatMul_4" + input: "train_op/gradients/compute_loss/concat_14_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_5_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/mul_5_grad/Mul_1" + input: "train_op/gradients/compute_loss/mul_5_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_5_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_5_grad/Sum_1" + input: "train_op/gradients/compute_loss/mul_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/mul_5_grad/Reshape" + input: "^train_op/gradients/compute_loss/mul_5_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/mul_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_5_grad/Reshape" + input: "^train_op/gradients/compute_loss/mul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_5_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 3 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/mul_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/mul_5_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/mul_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/mul_5_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 53248 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_8_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/Squeeze_3_grad/Reshape" + input: "compute_loss/concat_21" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_8_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/MatMul_7" + input: "train_op/gradients/compute_loss/Squeeze_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_8_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_8_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_8_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_8_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_8_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_8_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_8_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_8_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_8_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_7_grad/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: "train_op/gradients/compute_loss/Slice_7_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_7_grad/stack/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: "train_op/gradients/compute_loss/Slice_7_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_7_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_7_grad/stack/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: "train_op/gradients/compute_loss/Slice_7_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_7/begin" + input: "train_op/gradients/compute_loss/Slice_7_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_7_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_7_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_7_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_7_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_7_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_7_grad/sub" + input: "compute_loss/Slice_7/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_7_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_7_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_7_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_7_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_7_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_7_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_7_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_7_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_7_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/ExpandDims_10_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_7_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_5_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_5_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_10_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_14_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/MatMul_15_grad/tuple/control_dependency" + input: "compute_loss/concat_45" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_14_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/concat_49" + input: "train_op/gradients/compute_loss/MatMul_15_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_14_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_14_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_14_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_14_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_14_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_14_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_14_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_14_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_14_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_14_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_14_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_41_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_41_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_41/axis" + input: "train_op/gradients/compute_loss/concat_41_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_41_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_41_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_41_grad/Shape_2" + op: "Shape" + input: "compute_loss/concat_40" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_41_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_38" + input: "compute_loss/concat_39" + input: "compute_loss/concat_40" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_41_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_41_grad/mod" + input: "train_op/gradients/compute_loss/concat_41_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_41_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_41_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_41_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_15_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_41_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_41_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_41_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_15_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_41_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_41_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_41_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_15_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_41_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_41_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_41_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_41_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_41_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_41_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_41_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_41_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_41_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_41_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_41_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_41_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_41_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_41_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_41_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_41_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_41_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_41_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_4_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_4_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/Reshape_10_grad/Reshape" + input: "train_op/gradients/compute_loss/Squeeze_4_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_67_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_67_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_67/axis" + input: "train_op/gradients/compute_loss/concat_67_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_67_grad/Shape" + op: "Shape" + input: "compute_loss/concat_64" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_67_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_64" + input: "compute_loss/concat_65" + input: "compute_loss/concat_66" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_67_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_67_grad/mod" + input: "train_op/gradients/compute_loss/concat_67_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_67_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_67_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_67_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_21_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_67_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_67_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_67_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_21_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_67_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_67_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_67_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_21_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_67_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_67_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_67_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_67_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_67_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_67_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_67_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_67_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_67_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_67_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_67_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_67_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_67_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_67_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_67_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_67_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_67_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_67_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_63_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_63_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_63/axis" + input: "train_op/gradients/compute_loss/concat_63_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_63_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_63_grad/Shape_1" + op: "Shape" + input: "compute_loss/concat_61" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_63_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_60" + input: "compute_loss/concat_61" + input: "compute_loss/concat_62" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_63_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_63_grad/mod" + input: "train_op/gradients/compute_loss/concat_63_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_63_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_63_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_63_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_21_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_63_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_63_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_63_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_21_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_63_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_63_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_63_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_21_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_63_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_63_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_63_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_63_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_63_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_63_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_63_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_63_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_63_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_63_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_63_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_63_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_63_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_63_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_63_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_63_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_63_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_63_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_56_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_56_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_56/axis" + input: "train_op/gradients/compute_loss/concat_56_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_56_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_56_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_56_grad/Shape_2" + op: "Shape" + input: "compute_loss/zeros_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_56_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Cos_9" + input: "compute_loss/Neg_9" + input: "compute_loss/zeros_6" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_56_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_56_grad/mod" + input: "train_op/gradients/compute_loss/concat_56_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_56_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_56_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_56_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_59_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_56_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_56_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_56_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_59_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_56_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_56_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_56_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_59_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_56_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_56_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_56_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_56_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_56_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_56_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_56_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_56_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_56_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_56_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_56_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_56_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_56_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_56_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_56_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_56_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_56_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_56_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_57_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_57_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_57/axis" + input: "train_op/gradients/compute_loss/concat_57_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_57_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_57_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_57_grad/Shape_2" + op: "Shape" + input: "compute_loss/zeros_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_57_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Sin_9" + input: "compute_loss/Cos_9" + input: "compute_loss/zeros_6" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_57_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_57_grad/mod" + input: "train_op/gradients/compute_loss/concat_57_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_57_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_57_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_57_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_59_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_57_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_57_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_57_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_59_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_57_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_57_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_57_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_59_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_57_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_57_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_57_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_57_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_57_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_57_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_57_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_57_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_57_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_57_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_57_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_57_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_57_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_57_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_57_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_57_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_57_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_57_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_85_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_85_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_85/axis" + input: "train_op/gradients/compute_loss/concat_85_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_85_grad/Shape" + op: "Shape" + input: "compute_loss/zeros_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_85_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/zeros_8" + input: "compute_loss/Cos_14" + input: "compute_loss/Neg_14" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_85_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_85_grad/mod" + input: "train_op/gradients/compute_loss/concat_85_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_85_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_85_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_85_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_87_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_85_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_85_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_85_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_87_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_85_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_85_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_85_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_87_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_85_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_85_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_85_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_85_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_85_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_85_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_85_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_85_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_85_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_85_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_85_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_85_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_85_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_85_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_85_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_85_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_85_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_85_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_86_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_86_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_86/axis" + input: "train_op/gradients/compute_loss/concat_86_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_86_grad/Shape" + op: "Shape" + input: "compute_loss/zeros_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_86_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/zeros_8" + input: "compute_loss/Sin_14" + input: "compute_loss/Cos_14" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_86_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_86_grad/mod" + input: "train_op/gradients/compute_loss/concat_86_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_86_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_86_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_86_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_87_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_86_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_86_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_86_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_87_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_86_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_86_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_86_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_87_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_86_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_86_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_86_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_86_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_86_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_86_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_86_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_86_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_86_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_86_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_86_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_86_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_86_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_86_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_86_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_86_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_86_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_86_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_80_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_80_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_80/axis" + input: "train_op/gradients/compute_loss/concat_80_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_80_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_80_grad/Shape_1" + op: "Shape" + input: "compute_loss/zeros_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_80_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Cos_13" + input: "compute_loss/zeros_8" + input: "compute_loss/Sin_13" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_80_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_80_grad/mod" + input: "train_op/gradients/compute_loss/concat_80_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_80_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_80_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_80_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_83_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_80_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_80_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_80_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_83_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_80_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_80_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_80_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_83_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_80_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_80_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_80_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_80_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_80_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_80_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_80_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_80_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_80_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_80_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_80_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_80_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_80_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_80_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_80_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_80_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_80_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_80_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_82_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_82_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_82/axis" + input: "train_op/gradients/compute_loss/concat_82_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_82_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_82_grad/Shape_1" + op: "Shape" + input: "compute_loss/zeros_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_82_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Neg_13" + input: "compute_loss/zeros_8" + input: "compute_loss/Cos_13" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_82_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_82_grad/mod" + input: "train_op/gradients/compute_loss/concat_82_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_82_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_82_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_82_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_83_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_82_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_82_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_82_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_83_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_82_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_82_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_82_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_83_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_82_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_82_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_82_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_82_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_82_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_82_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_82_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_82_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_82_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_82_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_82_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_82_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_82_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_82_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_82_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_82_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_82_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_82_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_12_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_76_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_102" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_76_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_77_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_76_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_12_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_102" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_12_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_42" + input: "^train_op/gradients/AddN_102" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_12_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_12_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_12_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_17_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_103_grad/tuple/control_dependency_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_103" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_103_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_104_grad/tuple/control_dependency_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_103_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_17_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_103" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_17_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_56" + input: "^train_op/gradients/AddN_103" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_17_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_17_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_17_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_16_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_100_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_104" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_98_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_100_grad/tuple/control_dependency_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_98_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_16_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_104" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_16_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_54" + input: "^train_op/gradients/AddN_104" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_16_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_16_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_16_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_105" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_95_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Neg_15_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_95_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_15_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_52" + input: "^train_op/gradients/AddN_105" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_15_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_105" + input: "train_op/gradients/compute_loss/Sin_15_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_106" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_124_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Neg_20_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_124_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_20_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_66" + input: "^train_op/gradients/AddN_106" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_20_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_106" + input: "train_op/gradients/compute_loss/Sin_20_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_107" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_118_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/Neg_19_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_118_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_19_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_64" + input: "^train_op/gradients/AddN_107" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_19_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_107" + input: "train_op/gradients/compute_loss/Sin_19_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_108" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_18_grad/mul" + input: "train_op/gradients/compute_loss/Sin_18_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_18_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_62_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_62_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_108" + input: "train_op/gradients/compute_loss/ExpandDims_62_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_109" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_23_grad/mul" + input: "train_op/gradients/compute_loss/Sin_23_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_23_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_76_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_76_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_109" + input: "train_op/gradients/compute_loss/ExpandDims_76_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_110" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_22_grad/mul" + input: "train_op/gradients/compute_loss/Sin_22_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_22_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_74_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_74_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_110" + input: "train_op/gradients/compute_loss/ExpandDims_74_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_71_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_71_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_72_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_71_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_1_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/Squeeze_1_grad/Reshape" + input: "compute_loss/concat_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_1_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/MatMul" + input: "train_op/gradients/compute_loss/Squeeze_1_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_1_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_1_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_1_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_1_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_1_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_1_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_grad/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: "train_op/gradients/compute_loss/Slice_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_grad/stack/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: "train_op/gradients/compute_loss/Slice_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_grad/stack/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: "train_op/gradients/compute_loss/Slice_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice/begin" + input: "train_op/gradients/compute_loss/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_grad/sub" + input: "compute_loss/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/ExpandDims_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Reshape_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/mul_5_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_7_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/MatMul_8_grad/tuple/control_dependency" + input: "compute_loss/concat_25" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_7_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/concat_29" + input: "train_op/gradients/compute_loss/MatMul_8_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_7_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_7_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_7_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_7_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_7_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_7_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_7_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_7_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_7_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_21_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_21_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_21/axis" + input: "train_op/gradients/compute_loss/concat_21_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_21_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_21_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_21_grad/Shape_2" + op: "Shape" + input: "compute_loss/concat_20" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_21_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_18" + input: "compute_loss/concat_19" + input: "compute_loss/concat_20" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_21_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_21_grad/mod" + input: "train_op/gradients/compute_loss/concat_21_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_21_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_21_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_21_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_8_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_21_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_21_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_21_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_8_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_21_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_21_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_21_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_8_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_21_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_21_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_21_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_21_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_21_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_21_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_21_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_21_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_21_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_21_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_21_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_21_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_21_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_21_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_21_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_21_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_21_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_21_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_2_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_2_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/Reshape_5_grad/Reshape" + input: "train_op/gradients/compute_loss/Squeeze_2_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_49_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_49_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_49/axis" + input: "train_op/gradients/compute_loss/concat_49_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_49_grad/Shape" + op: "Shape" + input: "compute_loss/concat_46" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_49_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_46" + input: "compute_loss/concat_47" + input: "compute_loss/concat_48" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_49_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_49_grad/mod" + input: "train_op/gradients/compute_loss/concat_49_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_49_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_49_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_49_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_14_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_49_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_49_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_49_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_14_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_49_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_49_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_49_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_14_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_49_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_49_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_49_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_49_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_49_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_49_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_49_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_49_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_49_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_49_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_49_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_49_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_49_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_49_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_49_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_49_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_49_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_49_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_45_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_45_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_45/axis" + input: "train_op/gradients/compute_loss/concat_45_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_45_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_45_grad/Shape_1" + op: "Shape" + input: "compute_loss/concat_43" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_45_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_42" + input: "compute_loss/concat_43" + input: "compute_loss/concat_44" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_45_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_45_grad/mod" + input: "train_op/gradients/compute_loss/concat_45_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_45_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_45_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_45_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_14_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_45_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_45_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_45_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_14_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_45_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_45_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_45_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_14_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_45_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_45_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_45_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_45_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_45_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_45_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_45_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_45_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_45_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_45_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_45_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_45_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_45_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_45_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_45_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_45_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_45_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_45_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_38_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_38_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_38/axis" + input: "train_op/gradients/compute_loss/concat_38_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_38_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_38_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_38_grad/Shape_2" + op: "Shape" + input: "compute_loss/zeros_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_38_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Cos_6" + input: "compute_loss/Neg_6" + input: "compute_loss/zeros_4" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_38_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_38_grad/mod" + input: "train_op/gradients/compute_loss/concat_38_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_38_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_38_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_38_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_41_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_38_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_38_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_38_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_41_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_38_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_38_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_38_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_41_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_38_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_38_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_38_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_38_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_38_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_38_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_38_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_38_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_38_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_38_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_38_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_38_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_38_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_38_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_38_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_38_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_38_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_38_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_39_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_39_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_39/axis" + input: "train_op/gradients/compute_loss/concat_39_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_39_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_39_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_39_grad/Shape_2" + op: "Shape" + input: "compute_loss/zeros_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_39_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Sin_6" + input: "compute_loss/Cos_6" + input: "compute_loss/zeros_4" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_39_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_39_grad/mod" + input: "train_op/gradients/compute_loss/concat_39_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_39_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_39_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_39_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_41_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_39_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_39_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_39_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_41_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_39_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_39_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_39_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_41_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_39_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_39_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_39_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_39_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_39_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_39_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_39_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_39_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_39_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_39_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_39_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_39_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_39_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_39_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_39_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_39_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_39_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_39_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_111" + op: "AddN" + input: "train_op/gradients/compute_loss/Squeeze_6_grad/Reshape" + input: "train_op/gradients/compute_loss/Squeeze_4_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Squeeze_6_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_1_grad/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: "train_op/gradients/depth_prediction/truediv_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/depth_prediction/truediv_1_grad/Shape" + input: "train_op/gradients/depth_prediction/truediv_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_1_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/AddN_111" + input: "depth_prediction/depth_net/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/depth_prediction/truediv_1_grad/RealDiv" + input: "train_op/gradients/depth_prediction/truediv_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/depth_prediction/truediv_1_grad/Sum" + input: "train_op/gradients/depth_prediction/truediv_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_1_grad/Neg" + op: "Neg" + input: "depth_prediction/truediv_1/x" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_1_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/depth_prediction/truediv_1_grad/Neg" + input: "depth_prediction/depth_net/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_1_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/depth_prediction/truediv_1_grad/RealDiv_1" + input: "depth_prediction/depth_net/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_1_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_111" + input: "train_op/gradients/depth_prediction/truediv_1_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/depth_prediction/truediv_1_grad/mul" + input: "train_op/gradients/depth_prediction/truediv_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/depth_prediction/truediv_1_grad/Sum_1" + input: "train_op/gradients/depth_prediction/truediv_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/truediv_1_grad/Reshape" + input: "^train_op/gradients/depth_prediction/truediv_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/depth_prediction/truediv_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/truediv_1_grad/Reshape" + input: "^train_op/gradients/depth_prediction/truediv_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/truediv_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/truediv_1_grad/Reshape_1" + input: "^train_op/gradients/depth_prediction/truediv_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/truediv_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_65_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_65_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_65/axis" + input: "train_op/gradients/compute_loss/concat_65_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_65_grad/Shape" + op: "Shape" + input: "compute_loss/zeros_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_65_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/zeros_6" + input: "compute_loss/Cos_11" + input: "compute_loss/Neg_11" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_65_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_65_grad/mod" + input: "train_op/gradients/compute_loss/concat_65_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_65_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_65_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_65_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_67_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_65_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_65_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_65_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_67_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_65_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_65_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_65_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_67_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_65_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_65_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_65_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_65_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_65_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_65_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_65_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_65_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_65_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_65_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_65_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_65_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_65_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_65_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_65_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_65_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_65_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_65_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_66_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_66_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_66/axis" + input: "train_op/gradients/compute_loss/concat_66_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_66_grad/Shape" + op: "Shape" + input: "compute_loss/zeros_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_66_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/zeros_6" + input: "compute_loss/Sin_11" + input: "compute_loss/Cos_11" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_66_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_66_grad/mod" + input: "train_op/gradients/compute_loss/concat_66_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_66_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_66_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_66_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_67_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_66_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_66_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_66_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_67_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_66_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_66_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_66_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_67_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_66_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_66_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_66_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_66_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_66_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_66_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_66_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_66_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_66_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_66_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_66_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_66_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_66_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_66_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_66_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_66_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_66_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_66_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_60_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_60_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_60/axis" + input: "train_op/gradients/compute_loss/concat_60_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_60_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_60_grad/Shape_1" + op: "Shape" + input: "compute_loss/zeros_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_60_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Cos_10" + input: "compute_loss/zeros_6" + input: "compute_loss/Sin_10" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_60_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_60_grad/mod" + input: "train_op/gradients/compute_loss/concat_60_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_60_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_60_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_60_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_63_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_60_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_60_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_60_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_63_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_60_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_60_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_60_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_63_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_60_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_60_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_60_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_60_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_60_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_60_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_60_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_60_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_60_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_60_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_60_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_60_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_60_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_60_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_60_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_60_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_60_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_60_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_62_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_62_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_62/axis" + input: "train_op/gradients/compute_loss/concat_62_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_62_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_62_grad/Shape_1" + op: "Shape" + input: "compute_loss/zeros_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_62_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Neg_10" + input: "compute_loss/zeros_6" + input: "compute_loss/Cos_10" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_62_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_62_grad/mod" + input: "train_op/gradients/compute_loss/concat_62_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_62_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_62_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_62_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_63_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_62_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_62_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_62_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_63_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_62_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_62_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_62_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_63_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_62_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_62_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_62_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_62_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_62_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_62_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_62_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_62_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_62_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_62_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_62_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_62_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_62_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_62_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_62_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_62_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_62_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_62_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_9_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_56_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_112" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_56_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_57_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_56_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_9_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_112" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_9_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_32" + input: "^train_op/gradients/AddN_112" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_9_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_9_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_9_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_14_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_85_grad/tuple/control_dependency_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_113" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_85_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_86_grad/tuple/control_dependency_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_85_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_14_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_113" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_14_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_46" + input: "^train_op/gradients/AddN_113" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_14_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_14_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_14_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_13_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_82_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_114" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_80_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_82_grad/tuple/control_dependency_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_80_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_13_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_114" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_13_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_44" + input: "^train_op/gradients/AddN_114" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_13_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_13_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_13_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_115" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_77_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Neg_12_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_77_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_12_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_42" + input: "^train_op/gradients/AddN_115" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_12_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_115" + input: "train_op/gradients/compute_loss/Sin_12_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_116" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_104_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Neg_17_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_104_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_17_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_56" + input: "^train_op/gradients/AddN_116" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_17_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_116" + input: "train_op/gradients/compute_loss/Sin_17_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_117" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_98_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/Neg_16_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_98_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_16_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_54" + input: "^train_op/gradients/AddN_117" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_16_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_117" + input: "train_op/gradients/compute_loss/Sin_16_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_118" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_15_grad/mul" + input: "train_op/gradients/compute_loss/Sin_15_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_15_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_52_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_52_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_118" + input: "train_op/gradients/compute_loss/ExpandDims_52_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_119" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_20_grad/mul" + input: "train_op/gradients/compute_loss/Sin_20_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_20_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_66_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_66_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_119" + input: "train_op/gradients/compute_loss/ExpandDims_66_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_120" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_19_grad/mul" + input: "train_op/gradients/compute_loss/Sin_19_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_19_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_64_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_64_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_120" + input: "train_op/gradients/compute_loss/ExpandDims_64_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_61_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_61_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_62_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_61_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_75_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_75_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_76_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_75_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_73_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_73_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_74_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_73_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_21/Minimum" + input: "compute_loss/clip_by_value_21/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_71_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_71_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_21_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_21_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_21_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_21_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_21_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_21_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_grad/MatMul" + op: "BatchMatMul" + input: "train_op/gradients/compute_loss/MatMul_1_grad/tuple/control_dependency" + input: "compute_loss/concat_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_grad/MatMul_1" + op: "BatchMatMul" + input: "compute_loss/concat_11" + input: "train_op/gradients/compute_loss/MatMul_1_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/MatMul_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_grad/MatMul_1" +} +node { + name: "train_op/gradients/compute_loss/MatMul_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_grad/MatMul" + input: "^train_op/gradients/compute_loss/MatMul_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_grad/MatMul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/MatMul_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/MatMul_grad/MatMul_1" + input: "^train_op/gradients/compute_loss/MatMul_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/MatMul_grad/MatMul_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 3 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_3_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_3_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_3/axis" + input: "train_op/gradients/compute_loss/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_3_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_3_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_3_grad/Shape_2" + op: "Shape" + input: "compute_loss/concat_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_3_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat" + input: "compute_loss/concat_1" + input: "compute_loss/concat_2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_3_grad/mod" + input: "train_op/gradients/compute_loss/concat_3_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_3_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_3_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_3_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_1_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_3_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_3_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_3_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_1_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_3_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_3_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_3_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_1_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_3_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_3_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_3_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_3_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_3_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_3_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_3_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_3_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_3_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_3_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_3_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_3_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Squeeze_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/Reshape_grad/Reshape" + input: "train_op/gradients/compute_loss/Squeeze_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_29_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_29_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_29/axis" + input: "train_op/gradients/compute_loss/concat_29_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_29_grad/Shape" + op: "Shape" + input: "compute_loss/concat_26" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_29_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_26" + input: "compute_loss/concat_27" + input: "compute_loss/concat_28" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_29_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_29_grad/mod" + input: "train_op/gradients/compute_loss/concat_29_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_29_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_29_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_29_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_7_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_29_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_29_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_29_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_7_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_29_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_29_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_29_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_7_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_29_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_29_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_29_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_29_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_29_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_29_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_29_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_29_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_29_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_29_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_29_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_29_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_29_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_29_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_29_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_29_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_29_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_29_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_25_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_25_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_25/axis" + input: "train_op/gradients/compute_loss/concat_25_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_25_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_25_grad/Shape_1" + op: "Shape" + input: "compute_loss/concat_23" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_25_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_22" + input: "compute_loss/concat_23" + input: "compute_loss/concat_24" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_25_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_25_grad/mod" + input: "train_op/gradients/compute_loss/concat_25_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_25_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_25_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_25_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_7_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_25_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_25_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_25_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_7_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_25_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_25_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_25_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_7_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_25_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_25_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_25_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_25_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_25_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_25_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_25_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_25_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_25_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_25_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_25_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_25_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_25_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_25_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_25_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_25_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_25_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_25_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_18_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_18_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_18/axis" + input: "train_op/gradients/compute_loss/concat_18_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_18_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_18_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_18_grad/Shape_2" + op: "Shape" + input: "compute_loss/zeros_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_18_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Cos_3" + input: "compute_loss/Neg_3" + input: "compute_loss/zeros_2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_18_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_18_grad/mod" + input: "train_op/gradients/compute_loss/concat_18_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_18_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_18_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_18_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_21_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_18_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_18_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_18_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_21_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_18_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_18_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_18_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_21_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_18_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_18_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_18_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_18_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_18_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_18_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_18_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_18_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_18_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_18_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_18_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_18_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_18_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_18_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_18_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_18_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_18_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_18_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_19_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_19_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_19/axis" + input: "train_op/gradients/compute_loss/concat_19_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_19_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_19_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_19_grad/Shape_2" + op: "Shape" + input: "compute_loss/zeros_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_19_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Sin_3" + input: "compute_loss/Cos_3" + input: "compute_loss/zeros_2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_19_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_19_grad/mod" + input: "train_op/gradients/compute_loss/concat_19_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_19_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_19_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_19_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_21_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_19_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_19_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_19_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_21_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_19_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_19_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_19_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_21_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_19_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_19_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_19_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_19_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_19_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_19_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_19_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_19_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_19_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_19_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_19_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_19_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_19_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_19_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_19_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_19_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_19_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_19_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_47_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_47_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_47/axis" + input: "train_op/gradients/compute_loss/concat_47_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_47_grad/Shape" + op: "Shape" + input: "compute_loss/zeros_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_47_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/zeros_4" + input: "compute_loss/Cos_8" + input: "compute_loss/Neg_8" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_47_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_47_grad/mod" + input: "train_op/gradients/compute_loss/concat_47_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_47_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_47_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_47_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_49_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_47_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_47_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_47_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_49_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_47_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_47_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_47_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_49_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_47_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_47_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_47_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_47_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_47_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_47_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_47_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_47_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_47_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_47_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_47_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_47_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_47_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_47_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_47_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_47_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_47_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_47_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_48_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_48_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_48/axis" + input: "train_op/gradients/compute_loss/concat_48_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_48_grad/Shape" + op: "Shape" + input: "compute_loss/zeros_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_48_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/zeros_4" + input: "compute_loss/Sin_8" + input: "compute_loss/Cos_8" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_48_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_48_grad/mod" + input: "train_op/gradients/compute_loss/concat_48_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_48_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_48_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_48_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_49_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_48_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_48_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_48_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_49_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_48_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_48_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_48_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_49_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_48_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_48_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_48_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_48_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_48_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_48_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_48_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_48_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_48_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_48_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_48_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_48_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_48_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_48_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_48_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_48_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_48_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_48_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_42_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_42_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_42/axis" + input: "train_op/gradients/compute_loss/concat_42_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_42_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_42_grad/Shape_1" + op: "Shape" + input: "compute_loss/zeros_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_42_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Cos_7" + input: "compute_loss/zeros_4" + input: "compute_loss/Sin_7" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_42_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_42_grad/mod" + input: "train_op/gradients/compute_loss/concat_42_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_42_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_42_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_42_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_45_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_42_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_42_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_42_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_45_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_42_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_42_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_42_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_45_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_42_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_42_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_42_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_42_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_42_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_42_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_42_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_42_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_42_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_42_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_42_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_42_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_42_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_42_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_42_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_42_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_42_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_42_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_44_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_44_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_44/axis" + input: "train_op/gradients/compute_loss/concat_44_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_44_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_44_grad/Shape_1" + op: "Shape" + input: "compute_loss/zeros_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_44_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Neg_7" + input: "compute_loss/zeros_4" + input: "compute_loss/Cos_7" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_44_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_44_grad/mod" + input: "train_op/gradients/compute_loss/concat_44_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_44_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_44_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_44_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_45_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_44_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_44_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_44_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_45_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_44_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_44_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_44_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_45_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_44_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_44_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_44_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_44_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_44_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_44_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_44_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_44_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_44_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_44_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_44_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_44_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_44_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_44_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_44_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_44_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_44_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_44_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_6_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_38_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_121" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_38_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_39_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_38_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_6_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_121" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_6_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_22" + input: "^train_op/gradients/AddN_121" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_6_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_6_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_6_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_11_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_65_grad/tuple/control_dependency_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_122" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_65_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_66_grad/tuple/control_dependency_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_65_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_11_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_122" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_11_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_36" + input: "^train_op/gradients/AddN_122" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_11_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_11_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_11_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_10_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_62_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_123" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_60_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_62_grad/tuple/control_dependency_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_60_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_10_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_123" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_10_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_34" + input: "^train_op/gradients/AddN_123" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_10_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_10_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_10_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_124" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_57_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Neg_9_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_57_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_9_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_32" + input: "^train_op/gradients/AddN_124" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_9_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_124" + input: "train_op/gradients/compute_loss/Sin_9_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_125" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_86_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Neg_14_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_86_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_14_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_46" + input: "^train_op/gradients/AddN_125" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_14_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_125" + input: "train_op/gradients/compute_loss/Sin_14_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_126" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_80_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/Neg_13_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_80_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_13_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_44" + input: "^train_op/gradients/AddN_126" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_13_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_126" + input: "train_op/gradients/compute_loss/Sin_13_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_127" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_12_grad/mul" + input: "train_op/gradients/compute_loss/Sin_12_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_12_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_42_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_42_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_127" + input: "train_op/gradients/compute_loss/ExpandDims_42_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_128" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_17_grad/mul" + input: "train_op/gradients/compute_loss/Sin_17_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_17_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_56_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_56_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_128" + input: "train_op/gradients/compute_loss/ExpandDims_56_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_129" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_16_grad/mul" + input: "train_op/gradients/compute_loss/Sin_16_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_16_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_54_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_54_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_129" + input: "train_op/gradients/compute_loss/ExpandDims_54_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_51_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_51_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_52_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_51_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_65_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_65_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_66_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_65_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_63_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_63_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_64_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_63_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_18/Minimum" + input: "compute_loss/clip_by_value_18/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_61_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_61_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_18_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_18_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_18_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_18_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_18_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_18_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_23/Minimum" + input: "compute_loss/clip_by_value_23/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_75_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_75_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_23_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_23_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_23_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_23_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_23_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_23_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_22/Minimum" + input: "compute_loss/clip_by_value_22/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_73_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_73_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_22_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_22_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_22_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_22_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_22_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_22_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_52" + input: "compute_loss/clip_by_value_21/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_21_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_11_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_11_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_11/axis" + input: "train_op/gradients/compute_loss/concat_11_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_11_grad/Shape" + op: "Shape" + input: "compute_loss/concat_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_11_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_8" + input: "compute_loss/concat_9" + input: "compute_loss/concat_10" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_11_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_11_grad/mod" + input: "train_op/gradients/compute_loss/concat_11_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_11_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_11_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_11_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_11_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_11_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_11_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_11_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_11_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_11_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_11_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_11_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_11_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_11_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_11_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_11_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_11_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_11_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_11_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_11_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_11_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_11_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_11_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_11_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_11_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_11_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_11_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_11_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_7_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_7_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_7/axis" + input: "train_op/gradients/compute_loss/concat_7_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_7_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_7_grad/Shape_1" + op: "Shape" + input: "compute_loss/concat_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_7_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/concat_4" + input: "compute_loss/concat_5" + input: "compute_loss/concat_6" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_7_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_7_grad/mod" + input: "train_op/gradients/compute_loss/concat_7_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_7_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_7_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_7_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_7_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_7_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_7_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_7_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_7_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_7_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/MatMul_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_7_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_7_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_7_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_7_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_7_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_7_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_7_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_7_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_7_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_7_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_7_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_7_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_7_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_7_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_7_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_grad/mod" + op: "FloorMod" + input: "compute_loss/concat/axis" + input: "train_op/gradients/compute_loss/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_grad/Shape_2" + op: "Shape" + input: "compute_loss/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Cos" + input: "compute_loss/Neg" + input: "compute_loss/zeros" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_grad/mod" + input: "train_op/gradients/compute_loss/concat_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_1_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_1_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_1/axis" + input: "train_op/gradients/compute_loss/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_1_grad/Shape_2" + op: "Shape" + input: "compute_loss/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_1_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Sin" + input: "compute_loss/Cos" + input: "compute_loss/zeros" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_1_grad/mod" + input: "train_op/gradients/compute_loss/concat_1_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_1_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_1_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_1_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_1_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_1_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_1_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_1_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_1_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_1_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_1_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_1_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_1_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_1_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_1_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_1_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_1_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_1_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_1_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_1_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_130" + op: "AddN" + input: "train_op/gradients/compute_loss/Squeeze_2_grad/Reshape" + input: "train_op/gradients/compute_loss/Squeeze_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Squeeze_2_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_grad/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: "train_op/gradients/depth_prediction/truediv_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/depth_prediction/truediv_grad/Shape" + input: "train_op/gradients/depth_prediction/truediv_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_grad/RealDiv" + op: "RealDiv" + input: "train_op/gradients/AddN_130" + input: "depth_prediction/depth_net/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_grad/Sum" + op: "Sum" + input: "train_op/gradients/depth_prediction/truediv_grad/RealDiv" + input: "train_op/gradients/depth_prediction/truediv_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/depth_prediction/truediv_grad/Sum" + input: "train_op/gradients/depth_prediction/truediv_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_grad/Neg" + op: "Neg" + input: "depth_prediction/truediv/x" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_grad/RealDiv_1" + op: "RealDiv" + input: "train_op/gradients/depth_prediction/truediv_grad/Neg" + input: "depth_prediction/depth_net/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_grad/RealDiv_2" + op: "RealDiv" + input: "train_op/gradients/depth_prediction/truediv_grad/RealDiv_1" + input: "depth_prediction/depth_net/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_130" + input: "train_op/gradients/depth_prediction/truediv_grad/RealDiv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/depth_prediction/truediv_grad/mul" + input: "train_op/gradients/depth_prediction/truediv_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/depth_prediction/truediv_grad/Sum_1" + input: "train_op/gradients/depth_prediction/truediv_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/truediv_grad/Reshape" + input: "^train_op/gradients/depth_prediction/truediv_grad/Reshape_1" +} +node { + name: "train_op/gradients/depth_prediction/truediv_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/truediv_grad/Reshape" + input: "^train_op/gradients/depth_prediction/truediv_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/truediv_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/truediv_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/truediv_grad/Reshape_1" + input: "^train_op/gradients/depth_prediction/truediv_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/truediv_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_27_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_27_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_27/axis" + input: "train_op/gradients/compute_loss/concat_27_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_27_grad/Shape" + op: "Shape" + input: "compute_loss/zeros_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_27_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/zeros_2" + input: "compute_loss/Cos_5" + input: "compute_loss/Neg_5" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_27_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_27_grad/mod" + input: "train_op/gradients/compute_loss/concat_27_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_27_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_27_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_27_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_29_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_27_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_27_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_27_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_29_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_27_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_27_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_27_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_29_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_27_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_27_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_27_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_27_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_27_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_27_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_27_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_27_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_27_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_27_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_27_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_27_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_27_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_27_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_27_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_27_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_27_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_27_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_28_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_28_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_28/axis" + input: "train_op/gradients/compute_loss/concat_28_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_28_grad/Shape" + op: "Shape" + input: "compute_loss/zeros_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_28_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/zeros_2" + input: "compute_loss/Sin_5" + input: "compute_loss/Cos_5" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_28_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_28_grad/mod" + input: "train_op/gradients/compute_loss/concat_28_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_28_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_28_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_28_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_29_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_28_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_28_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_28_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_29_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_28_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_28_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_28_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_29_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_28_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_28_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_28_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_28_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_28_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_28_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_28_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_28_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_28_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_28_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_28_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_28_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_28_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_28_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_28_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_28_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_28_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_28_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_22_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_22_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_22/axis" + input: "train_op/gradients/compute_loss/concat_22_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_22_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_22_grad/Shape_1" + op: "Shape" + input: "compute_loss/zeros_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_22_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Cos_4" + input: "compute_loss/zeros_2" + input: "compute_loss/Sin_4" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_22_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_22_grad/mod" + input: "train_op/gradients/compute_loss/concat_22_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_22_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_22_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_22_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_25_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_22_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_22_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_22_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_25_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_22_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_22_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_22_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_25_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_22_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_22_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_22_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_22_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_22_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_22_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_22_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_22_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_22_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_22_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_22_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_22_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_22_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_22_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_22_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_22_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_22_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_22_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_24_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_24_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_24/axis" + input: "train_op/gradients/compute_loss/concat_24_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_24_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_24_grad/Shape_1" + op: "Shape" + input: "compute_loss/zeros_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_24_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Neg_4" + input: "compute_loss/zeros_2" + input: "compute_loss/Cos_4" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_24_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_24_grad/mod" + input: "train_op/gradients/compute_loss/concat_24_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_24_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_24_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_24_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_25_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_24_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_24_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_24_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_25_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_24_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_24_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_24_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_25_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_24_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_24_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_24_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_24_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_24_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_24_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_24_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_24_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_24_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_24_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_24_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_24_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_24_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_24_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_24_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_24_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_24_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_24_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_3_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_18_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_131" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_18_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_19_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_18_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_3_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_131" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_3_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_12" + input: "^train_op/gradients/AddN_131" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_3_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_3_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_3_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_8_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_47_grad/tuple/control_dependency_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_132" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_47_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_48_grad/tuple/control_dependency_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_47_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_8_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_132" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_8_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_26" + input: "^train_op/gradients/AddN_132" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_8_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_8_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_8_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_7_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_44_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_133" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_42_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_44_grad/tuple/control_dependency_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_42_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_7_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_133" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_7_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_24" + input: "^train_op/gradients/AddN_133" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_7_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_7_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_7_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_134" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_39_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Neg_6_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_39_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_6_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_22" + input: "^train_op/gradients/AddN_134" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_6_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_134" + input: "train_op/gradients/compute_loss/Sin_6_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_135" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_66_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Neg_11_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_66_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_11_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_36" + input: "^train_op/gradients/AddN_135" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_11_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_135" + input: "train_op/gradients/compute_loss/Sin_11_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_136" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_60_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/Neg_10_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_60_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_10_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_34" + input: "^train_op/gradients/AddN_136" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_10_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_136" + input: "train_op/gradients/compute_loss/Sin_10_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_137" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_9_grad/mul" + input: "train_op/gradients/compute_loss/Sin_9_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_9_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_32_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_32_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_137" + input: "train_op/gradients/compute_loss/ExpandDims_32_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_138" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_14_grad/mul" + input: "train_op/gradients/compute_loss/Sin_14_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_14_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_46_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_46_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_138" + input: "train_op/gradients/compute_loss/ExpandDims_46_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_139" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_13_grad/mul" + input: "train_op/gradients/compute_loss/Sin_13_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_13_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_44_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_44_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_139" + input: "train_op/gradients/compute_loss/ExpandDims_44_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_41_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_41_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_42_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_41_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_55_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_55_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_56_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_55_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_53_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_53_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_54_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_53_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_15/Minimum" + input: "compute_loss/clip_by_value_15/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_51_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_51_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_15_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_15_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_15_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_15_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_15_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_15_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_20/Minimum" + input: "compute_loss/clip_by_value_20/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_65_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_65_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_20_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_20_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_20_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_20_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_20_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_20_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_19/Minimum" + input: "compute_loss/clip_by_value_19/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_63_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_63_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_19_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_19_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_19_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_19_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_19_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_19_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_45" + input: "compute_loss/clip_by_value_18/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_18_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_50" + input: "compute_loss/clip_by_value_23/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_23_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_51" + input: "compute_loss/clip_by_value_22/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_22_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_52_grad/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: "train_op/gradients/compute_loss/Slice_52_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_52_grad/stack/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: "train_op/gradients/compute_loss/Slice_52_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_52_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_52_grad/stack/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: "train_op/gradients/compute_loss/Slice_52_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_52/begin" + input: "train_op/gradients/compute_loss/Slice_52_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_52_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_52_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_52_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_52_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_52_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_52_grad/sub" + input: "compute_loss/Slice_52/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_52_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_52_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_52_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_52_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_52_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_52_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_52_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_52_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_52_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_21/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_52_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_9_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_9_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_9/axis" + input: "train_op/gradients/compute_loss/concat_9_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_9_grad/Shape" + op: "Shape" + input: "compute_loss/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_9_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/zeros" + input: "compute_loss/Cos_2" + input: "compute_loss/Neg_2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_9_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_9_grad/mod" + input: "train_op/gradients/compute_loss/concat_9_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_9_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_9_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_9_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_11_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_9_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_9_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_9_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_11_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_9_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_9_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_9_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_11_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_9_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_9_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_9_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_9_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_9_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_9_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_9_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_9_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_9_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_9_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_9_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_9_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_9_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_9_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_9_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_10_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_10_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_10/axis" + input: "train_op/gradients/compute_loss/concat_10_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_10_grad/Shape" + op: "Shape" + input: "compute_loss/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_10_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/zeros" + input: "compute_loss/Sin_2" + input: "compute_loss/Cos_2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_10_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_10_grad/mod" + input: "train_op/gradients/compute_loss/concat_10_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_10_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_10_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_10_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_11_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_10_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_10_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_10_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_11_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_10_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_10_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_10_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_11_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_10_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_10_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_10_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_10_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_10_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_10_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_10_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_10_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_10_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_10_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_10_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_10_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_10_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_10_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_10_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_4_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_4_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_4/axis" + input: "train_op/gradients/compute_loss/concat_4_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_4_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_4_grad/Shape_1" + op: "Shape" + input: "compute_loss/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_4_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Cos_1" + input: "compute_loss/zeros" + input: "compute_loss/Sin_1" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_4_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_4_grad/mod" + input: "train_op/gradients/compute_loss/concat_4_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_4_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_4_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_4_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_7_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_4_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_4_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_4_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_7_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_4_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_4_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_4_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_7_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_4_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_4_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_4_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_4_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_4_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_4_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_4_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_4_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_4_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_4_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_4_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_4_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_6_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_6_grad/mod" + op: "FloorMod" + input: "compute_loss/concat_6/axis" + input: "train_op/gradients/compute_loss/concat_6_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_6_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_6_grad/Shape_1" + op: "Shape" + input: "compute_loss/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_6_grad/ShapeN" + op: "ShapeN" + input: "compute_loss/Neg_1" + input: "compute_loss/zeros" + input: "compute_loss/Cos_1" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_6_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/compute_loss/concat_6_grad/mod" + input: "train_op/gradients/compute_loss/concat_6_grad/ShapeN" + input: "train_op/gradients/compute_loss/concat_6_grad/ShapeN:1" + input: "train_op/gradients/compute_loss/concat_6_grad/ShapeN:2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_6_grad/Slice" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_7_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_6_grad/ConcatOffset" + input: "train_op/gradients/compute_loss/concat_6_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_6_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_7_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_6_grad/ConcatOffset:1" + input: "train_op/gradients/compute_loss/concat_6_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_6_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/compute_loss/concat_7_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/concat_6_grad/ConcatOffset:2" + input: "train_op/gradients/compute_loss/concat_6_grad/ShapeN:2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_6_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/concat_6_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_6_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_6_grad/Slice_2" +} +node { + name: "train_op/gradients/compute_loss/concat_6_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_6_grad/Slice" + input: "^train_op/gradients/compute_loss/concat_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_6_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_6_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_6_grad/Slice_1" + input: "^train_op/gradients/compute_loss/concat_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_6_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/concat_6_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/compute_loss/concat_6_grad/Slice_2" + input: "^train_op/gradients/compute_loss/concat_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_6_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_140" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_1_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_140" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_2" + input: "^train_op/gradients/AddN_140" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_141" + op: "AddN" + input: "train_op/gradients/compute_loss/strided_slice_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_1_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_2_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_3_grad/StridedSliceGrad" + input: "train_op/gradients/depth_prediction/truediv_grad/tuple/control_dependency_1" + attr { + key: "N" + value { + i: 5 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_3_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_3_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/depth_prediction/depth_net/add_3_grad/Shape" + input: "train_op/gradients/depth_prediction/depth_net/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_3_grad/Sum" + op: "Sum" + input: "train_op/gradients/AddN_141" + input: "train_op/gradients/depth_prediction/depth_net/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_3_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/depth_prediction/depth_net/add_3_grad/Sum" + input: "train_op/gradients/depth_prediction/depth_net/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_3_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/AddN_141" + input: "train_op/gradients/depth_prediction/depth_net/add_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_3_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/depth_prediction/depth_net/add_3_grad/Sum_1" + input: "train_op/gradients/depth_prediction/depth_net/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/add_3_grad/Reshape" + input: "^train_op/gradients/depth_prediction/depth_net/add_3_grad/Reshape_1" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/add_3_grad/Reshape" + input: "^train_op/gradients/depth_prediction/depth_net/add_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/add_3_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/add_3_grad/Reshape_1" + input: "^train_op/gradients/depth_prediction/depth_net/add_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/add_3_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_5_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_27_grad/tuple/control_dependency_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_142" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_27_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_28_grad/tuple/control_dependency_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_27_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_5_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_142" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_5_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_16" + input: "^train_op/gradients/AddN_142" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_5_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_5_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_5_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_4_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_24_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_143" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_22_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_24_grad/tuple/control_dependency_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_22_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_4_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_143" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_4_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_14" + input: "^train_op/gradients/AddN_143" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_4_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_4_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_4_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_144" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_19_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Neg_3_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_19_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_3_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_12" + input: "^train_op/gradients/AddN_144" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_3_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_144" + input: "train_op/gradients/compute_loss/Sin_3_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_145" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_48_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Neg_8_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_48_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_8_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_26" + input: "^train_op/gradients/AddN_145" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_8_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_145" + input: "train_op/gradients/compute_loss/Sin_8_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_146" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_42_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/Neg_7_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_42_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_7_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_24" + input: "^train_op/gradients/AddN_146" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_7_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_146" + input: "train_op/gradients/compute_loss/Sin_7_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_147" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_6_grad/mul" + input: "train_op/gradients/compute_loss/Sin_6_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_6_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_22_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_22_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_147" + input: "train_op/gradients/compute_loss/ExpandDims_22_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_148" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_11_grad/mul" + input: "train_op/gradients/compute_loss/Sin_11_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_11_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_36_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_36_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_148" + input: "train_op/gradients/compute_loss/ExpandDims_36_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_149" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_10_grad/mul" + input: "train_op/gradients/compute_loss/Sin_10_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_10_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_34_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_34_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_149" + input: "train_op/gradients/compute_loss/ExpandDims_34_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_31_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_31_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_32_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_31_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_45_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_45_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_46_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_45_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_43_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_43_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_44_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_43_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_12/Minimum" + input: "compute_loss/clip_by_value_12/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_41_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_41_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_12_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_12_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_12_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_12_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_12_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_12_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_17/Minimum" + input: "compute_loss/clip_by_value_17/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_55_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_55_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_17_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_17_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_17_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_17_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_17_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_17_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_16/Minimum" + input: "compute_loss/clip_by_value_16/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_53_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_53_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_16_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_16_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_16_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_16_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_16_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_16_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_38" + input: "compute_loss/clip_by_value_15/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_15_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_43" + input: "compute_loss/clip_by_value_20/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_20_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_44" + input: "compute_loss/clip_by_value_19/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_19_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_45_grad/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: "train_op/gradients/compute_loss/Slice_45_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_45_grad/stack/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: "train_op/gradients/compute_loss/Slice_45_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_45_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_45_grad/stack/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: "train_op/gradients/compute_loss/Slice_45_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_45/begin" + input: "train_op/gradients/compute_loss/Slice_45_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_45_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_45_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_45_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_45_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_45_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_45_grad/sub" + input: "compute_loss/Slice_45/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_45_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_45_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_45_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_45_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_45_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_45_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_45_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_45_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_45_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_18/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_45_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_50_grad/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: "train_op/gradients/compute_loss/Slice_50_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_50_grad/stack/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: "train_op/gradients/compute_loss/Slice_50_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_50_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_50_grad/stack/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: "train_op/gradients/compute_loss/Slice_50_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_50/begin" + input: "train_op/gradients/compute_loss/Slice_50_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_50_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_50_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_50_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_50_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_50_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_50_grad/sub" + input: "compute_loss/Slice_50/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_50_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_50_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_50_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_50_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_50_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_50_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_50_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_50_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_50_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_23/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_50_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_51_grad/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: "train_op/gradients/compute_loss/Slice_51_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_51_grad/stack/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: "train_op/gradients/compute_loss/Slice_51_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_51_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_51_grad/stack/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: "train_op/gradients/compute_loss/Slice_51_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_51/begin" + input: "train_op/gradients/compute_loss/Slice_51_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_51_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_51_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_51_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_51_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_51_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_51_grad/sub" + input: "compute_loss/Slice_51/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_51_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_51_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_51_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_51_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_51_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_51_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_51_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_51_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_51_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_22/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_51_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_2_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_9_grad/tuple/control_dependency_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_150" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_9_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/concat_10_grad/tuple/control_dependency_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_9_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_2_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_150" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_2_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_6" + input: "^train_op/gradients/AddN_150" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_2_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_2_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_2_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Neg_1_grad/Neg" + op: "Neg" + input: "train_op/gradients/compute_loss/concat_6_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_151" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_4_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/concat_6_grad/tuple/control_dependency_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_4_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_1_grad/Neg" + op: "Neg" + input: "train_op/gradients/AddN_151" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_1_grad/Sin" + op: "Sin" + input: "compute_loss/ExpandDims_4" + input: "^train_op/gradients/AddN_151" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Cos_1_grad/mul" + op: "Mul" + input: "train_op/gradients/compute_loss/Cos_1_grad/Neg" + input: "train_op/gradients/compute_loss/Cos_1_grad/Sin" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_152" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_1_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Neg_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_1_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_2" + input: "^train_op/gradients/AddN_152" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_152" + input: "train_op/gradients/compute_loss/Sin_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/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: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/Shape" + input: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/Mul" + op: "Mul" + input: "train_op/gradients/depth_prediction/depth_net/add_3_grad/tuple/control_dependency" + input: "depth_prediction/depth_net/disp1/Sigmoid" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/Sum" + op: "Sum" + input: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/Mul" + input: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/Sum" + input: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/Mul_1" + op: "Mul" + input: "depth_prediction/depth_net/mul_3/x" + input: "train_op/gradients/depth_prediction/depth_net/add_3_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/Mul_1" + input: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/Sum_1" + input: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/mul_3_grad/Reshape" + input: "^train_op/gradients/depth_prediction/depth_net/mul_3_grad/Reshape_1" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/Reshape" + input: "^train_op/gradients/depth_prediction/depth_net/mul_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/mul_3_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/Reshape_1" + input: "^train_op/gradients/depth_prediction/depth_net/mul_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/mul_3_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_153" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_28_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Neg_5_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_28_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_5_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_16" + input: "^train_op/gradients/AddN_153" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_5_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_153" + input: "train_op/gradients/compute_loss/Sin_5_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_154" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_22_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/Neg_4_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_22_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_4_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_14" + input: "^train_op/gradients/AddN_154" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_4_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_154" + input: "train_op/gradients/compute_loss/Sin_4_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_155" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_3_grad/mul" + input: "train_op/gradients/compute_loss/Sin_3_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_3_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_12_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_12_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_155" + input: "train_op/gradients/compute_loss/ExpandDims_12_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_156" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_8_grad/mul" + input: "train_op/gradients/compute_loss/Sin_8_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_8_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_26_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_26_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_156" + input: "train_op/gradients/compute_loss/ExpandDims_26_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_157" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_7_grad/mul" + input: "train_op/gradients/compute_loss/Sin_7_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_7_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_24_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_24_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_157" + input: "train_op/gradients/compute_loss/ExpandDims_24_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_21_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_21_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_22_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_21_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_35_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_35_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_36_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_35_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_33_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_33_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_34_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_33_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_9/Minimum" + input: "compute_loss/clip_by_value_9/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_31_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_31_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_9_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_9_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_9_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_9_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_14/Minimum" + input: "compute_loss/clip_by_value_14/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_45_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_45_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_14_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_14_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_14_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_14_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_14_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_14_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_13/Minimum" + input: "compute_loss/clip_by_value_13/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_43_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_43_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_13_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_13_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_13_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_13_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_13_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_13_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_31" + input: "compute_loss/clip_by_value_12/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_12_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_36" + input: "compute_loss/clip_by_value_17/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_17_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_37" + input: "compute_loss/clip_by_value_16/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_16_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_38_grad/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: "train_op/gradients/compute_loss/Slice_38_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_38_grad/stack/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: "train_op/gradients/compute_loss/Slice_38_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_38_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_38_grad/stack/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: "train_op/gradients/compute_loss/Slice_38_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_38/begin" + input: "train_op/gradients/compute_loss/Slice_38_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_38_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_38_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_38_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_38_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_38_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_38_grad/sub" + input: "compute_loss/Slice_38/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_38_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_38_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_38_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_38_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_38_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_38_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_38_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_38_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_38_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_15/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_38_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_43_grad/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: "train_op/gradients/compute_loss/Slice_43_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_43_grad/stack/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: "train_op/gradients/compute_loss/Slice_43_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_43_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_43_grad/stack/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: "train_op/gradients/compute_loss/Slice_43_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_43/begin" + input: "train_op/gradients/compute_loss/Slice_43_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_43_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_43_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_43_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_43_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_43_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_43_grad/sub" + input: "compute_loss/Slice_43/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_43_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_43_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_43_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_43_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_43_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_43_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_43_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_43_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_43_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_20/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_43_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_44_grad/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: "train_op/gradients/compute_loss/Slice_44_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_44_grad/stack/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: "train_op/gradients/compute_loss/Slice_44_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_44_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_44_grad/stack/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: "train_op/gradients/compute_loss/Slice_44_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_44/begin" + input: "train_op/gradients/compute_loss/Slice_44_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_44_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_44_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_44_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_44_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_44_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_44_grad/sub" + input: "compute_loss/Slice_44/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_44_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_44_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_44_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_44_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_44_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_44_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_44_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_44_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_44_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_19/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_44_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_158" + op: "AddN" + input: "train_op/gradients/compute_loss/Slice_49_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_52_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_50_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_51_grad/Pad" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Slice_49_grad/Pad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_77_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_77_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_77_grad/Shape" + input: "compute_loss/strided_slice_77/stack" + input: "compute_loss/strided_slice_77/stack_1" + input: "compute_loss/strided_slice_77/stack_2" + input: "train_op/gradients/AddN_158" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 5 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 5 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "train_op/gradients/AddN_159" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_10_grad/tuple/control_dependency_1" + input: "train_op/gradients/compute_loss/Neg_2_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_10_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_2_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_6" + input: "^train_op/gradients/AddN_159" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_2_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_159" + input: "train_op/gradients/compute_loss/Sin_2_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_160" + op: "AddN" + input: "train_op/gradients/compute_loss/concat_4_grad/tuple/control_dependency_2" + input: "train_op/gradients/compute_loss/Neg_1_grad/Neg" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/concat_4_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_1_grad/Cos" + op: "Cos" + input: "compute_loss/ExpandDims_4" + input: "^train_op/gradients/AddN_160" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Sin_1_grad/mul" + op: "Mul" + input: "train_op/gradients/AddN_160" + input: "train_op/gradients/compute_loss/Sin_1_grad/Cos" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_161" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_grad/mul" + input: "train_op/gradients/compute_loss/Sin_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_2_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_2_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_161" + input: "train_op/gradients/compute_loss/ExpandDims_2_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp1/Sigmoid_grad/SigmoidGrad" + op: "SigmoidGrad" + input: "depth_prediction/depth_net/disp1/Sigmoid" + input: "train_op/gradients/depth_prediction/depth_net/mul_3_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_162" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_5_grad/mul" + input: "train_op/gradients/compute_loss/Sin_5_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_5_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_16_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_16_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_162" + input: "train_op/gradients/compute_loss/ExpandDims_16_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_163" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_4_grad/mul" + input: "train_op/gradients/compute_loss/Sin_4_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_4_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_14_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_14_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_163" + input: "train_op/gradients/compute_loss/ExpandDims_14_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_11_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_11_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_12_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_11_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_25_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_25_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_26_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_25_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_23_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_23_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_24_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_23_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_6/Minimum" + input: "compute_loss/clip_by_value_6/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_21_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_21_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_6_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_6_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_6_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_6_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_11/Minimum" + input: "compute_loss/clip_by_value_11/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_35_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_35_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_11_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_11_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_11_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_11_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_11_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_11_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_10/Minimum" + input: "compute_loss/clip_by_value_10/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_33_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_33_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_10_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_10_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_10_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_10_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_24" + input: "compute_loss/clip_by_value_9/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_9_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_29" + input: "compute_loss/clip_by_value_14/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_14_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_30" + input: "compute_loss/clip_by_value_13/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_13_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_31_grad/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: "train_op/gradients/compute_loss/Slice_31_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_31_grad/stack/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: "train_op/gradients/compute_loss/Slice_31_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_31_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_31_grad/stack/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: "train_op/gradients/compute_loss/Slice_31_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_31/begin" + input: "train_op/gradients/compute_loss/Slice_31_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_31_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_31_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_31_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_31_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_31_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_31_grad/sub" + input: "compute_loss/Slice_31/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_31_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_31_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_31_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_31_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_31_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_31_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_31_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_31_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_31_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_12/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_31_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_36_grad/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: "train_op/gradients/compute_loss/Slice_36_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_36_grad/stack/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: "train_op/gradients/compute_loss/Slice_36_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_36_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_36_grad/stack/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: "train_op/gradients/compute_loss/Slice_36_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_36/begin" + input: "train_op/gradients/compute_loss/Slice_36_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_36_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_36_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_36_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_36_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_36_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_36_grad/sub" + input: "compute_loss/Slice_36/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_36_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_36_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_36_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_36_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_36_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_36_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_36_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_36_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_36_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_17/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_36_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_37_grad/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: "train_op/gradients/compute_loss/Slice_37_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_37_grad/stack/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: "train_op/gradients/compute_loss/Slice_37_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_37_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_37_grad/stack/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: "train_op/gradients/compute_loss/Slice_37_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_37/begin" + input: "train_op/gradients/compute_loss/Slice_37_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_37_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_37_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_37_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_37_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_37_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_37_grad/sub" + input: "compute_loss/Slice_37/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_37_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_37_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_37_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_37_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_37_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_37_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_37_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_37_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_37_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_16/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_37_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_164" + op: "AddN" + input: "train_op/gradients/compute_loss/Slice_42_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_45_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_43_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_44_grad/Pad" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Slice_42_grad/Pad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_73_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_73_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_73_grad/Shape" + input: "compute_loss/strided_slice_73/stack" + input: "compute_loss/strided_slice_73/stack_1" + input: "compute_loss/strided_slice_73/stack_2" + input: "train_op/gradients/AddN_164" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 5 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 5 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "train_op/gradients/AddN_165" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_2_grad/mul" + input: "train_op/gradients/compute_loss/Sin_2_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_2_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_6_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_6_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_165" + input: "train_op/gradients/compute_loss/ExpandDims_6_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_166" + op: "AddN" + input: "train_op/gradients/compute_loss/Cos_1_grad/mul" + input: "train_op/gradients/compute_loss/Sin_1_grad/mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Cos_1_grad/mul" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_4_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_4_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/AddN_166" + input: "train_op/gradients/compute_loss/ExpandDims_4_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_2_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp1/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/disp1/Sigmoid_grad/SigmoidGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp1/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/disp1/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/disp1/Sigmoid_grad/SigmoidGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp1/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/disp1/Sigmoid_grad/SigmoidGrad" + input: "^train_op/gradients/depth_prediction/depth_net/disp1/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/disp1/Sigmoid_grad/SigmoidGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp1/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/disp1/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/disp1/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/disp1/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_15_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_15_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_16_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_15_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_13_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_13_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_14_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_13_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_3/Minimum" + input: "compute_loss/clip_by_value_3/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_11_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_3_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_3_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_3_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_8/Minimum" + input: "compute_loss/clip_by_value_8/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_25_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_25_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_8_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_8_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_8_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_8_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_7/Minimum" + input: "compute_loss/clip_by_value_7/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_23_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_23_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_7_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_7_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_7_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_7_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_17" + input: "compute_loss/clip_by_value_6/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_6_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_22" + input: "compute_loss/clip_by_value_11/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_11_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_23" + input: "compute_loss/clip_by_value_10/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_10_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_24_grad/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: "train_op/gradients/compute_loss/Slice_24_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_24_grad/stack/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: "train_op/gradients/compute_loss/Slice_24_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_24_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_24_grad/stack/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: "train_op/gradients/compute_loss/Slice_24_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_24/begin" + input: "train_op/gradients/compute_loss/Slice_24_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_24_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_24_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_24_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_24_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_24_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_24_grad/sub" + input: "compute_loss/Slice_24/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_24_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_24_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_24_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_24_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_24_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_24_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_24_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_24_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_24_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_9/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_24_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_29_grad/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: "train_op/gradients/compute_loss/Slice_29_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_29_grad/stack/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: "train_op/gradients/compute_loss/Slice_29_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_29_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_29_grad/stack/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: "train_op/gradients/compute_loss/Slice_29_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_29/begin" + input: "train_op/gradients/compute_loss/Slice_29_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_29_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_29_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_29_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_29_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_29_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_29_grad/sub" + input: "compute_loss/Slice_29/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_29_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_29_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_29_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_29_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_29_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_29_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_29_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_29_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_29_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_14/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_29_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_30_grad/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: "train_op/gradients/compute_loss/Slice_30_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_30_grad/stack/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: "train_op/gradients/compute_loss/Slice_30_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_30_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_30_grad/stack/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: "train_op/gradients/compute_loss/Slice_30_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_30/begin" + input: "train_op/gradients/compute_loss/Slice_30_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_30_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_30_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_30_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_30_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_30_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_30_grad/sub" + input: "compute_loss/Slice_30/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_30_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_30_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_30_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_30_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_30_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_30_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_30_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_30_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_30_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_13/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_30_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_167" + op: "AddN" + input: "train_op/gradients/compute_loss/Slice_35_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_38_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_36_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_37_grad/Pad" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Slice_35_grad/Pad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_57_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_57_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_57_grad/Shape" + input: "compute_loss/strided_slice_57/stack" + input: "compute_loss/strided_slice_57/stack_1" + input: "compute_loss/strided_slice_57/stack_2" + input: "train_op/gradients/AddN_167" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 5 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 5 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_5_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_5_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_6_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_5_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_3_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/ExpandDims_3_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_4_grad/Reshape" + input: "train_op/gradients/compute_loss/ExpandDims_3_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value/Minimum" + input: "compute_loss/clip_by_value/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_1_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_1_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp1/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/icnv1/Relu" + input: "depth_net/disp1/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp1/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/disp1/Conv2D_grad/ShapeN" + input: "depth_net/disp1/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/disp1/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp1/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/icnv1/Relu" + input: "train_op/gradients/depth_prediction/depth_net/disp1/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/disp1/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp1/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/disp1/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/disp1/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp1/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/disp1/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/disp1/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/disp1/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp1/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/disp1/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/disp1/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/disp1/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_5/Minimum" + input: "compute_loss/clip_by_value_5/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_15_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_15_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_5_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_5_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_5_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_5_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_4/Minimum" + input: "compute_loss/clip_by_value_4/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_13_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_13_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_4_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_4_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_4_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_4_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_10" + input: "compute_loss/clip_by_value_3/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_3_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_15" + input: "compute_loss/clip_by_value_8/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_8_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_16" + input: "compute_loss/clip_by_value_7/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_7_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_17_grad/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: "train_op/gradients/compute_loss/Slice_17_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_17_grad/stack/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: "train_op/gradients/compute_loss/Slice_17_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_17_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_17_grad/stack/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: "train_op/gradients/compute_loss/Slice_17_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_17/begin" + input: "train_op/gradients/compute_loss/Slice_17_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_17_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_17_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_17_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_17_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_17_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_17_grad/sub" + input: "compute_loss/Slice_17/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_17_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_17_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_17_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_17_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_17_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_17_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_17_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_17_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_17_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_6/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_17_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_22_grad/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: "train_op/gradients/compute_loss/Slice_22_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_22_grad/stack/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: "train_op/gradients/compute_loss/Slice_22_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_22_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_22_grad/stack/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: "train_op/gradients/compute_loss/Slice_22_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_22/begin" + input: "train_op/gradients/compute_loss/Slice_22_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_22_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_22_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_22_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_22_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_22_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_22_grad/sub" + input: "compute_loss/Slice_22/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_22_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_22_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_22_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_22_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_22_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_22_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_22_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_22_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_22_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_11/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_22_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_23_grad/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: "train_op/gradients/compute_loss/Slice_23_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_23_grad/stack/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: "train_op/gradients/compute_loss/Slice_23_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_23_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_23_grad/stack/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: "train_op/gradients/compute_loss/Slice_23_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_23/begin" + input: "train_op/gradients/compute_loss/Slice_23_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_23_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_23_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_23_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_23_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_23_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_23_grad/sub" + input: "compute_loss/Slice_23/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_23_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_23_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_23_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_23_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_23_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_23_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_23_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_23_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_23_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_10/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_23_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_168" + op: "AddN" + input: "train_op/gradients/compute_loss/Slice_28_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_31_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_29_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_30_grad/Pad" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Slice_28_grad/Pad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_53_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_53_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_53_grad/Shape" + input: "compute_loss/strided_slice_53/stack" + input: "compute_loss/strided_slice_53/stack_1" + input: "compute_loss/strided_slice_53/stack_2" + input: "train_op/gradients/AddN_168" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 5 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 5 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_2/Minimum" + input: "compute_loss/clip_by_value_2/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_5_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_5_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_2_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_2_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_2_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1_grad/GreaterEqual" + op: "GreaterEqual" + input: "compute_loss/clip_by_value_1/Minimum" + input: "compute_loss/clip_by_value_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/ExpandDims_3_grad/Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/GreaterEqual" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/zeros" + input: "train_op/gradients/compute_loss/ExpandDims_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_3" + input: "compute_loss/clip_by_value/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv1/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/depth_prediction/depth_net/disp1/Conv2D_grad/tuple/control_dependency" + input: "depth_prediction/depth_net/icnv1/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_8" + input: "compute_loss/clip_by_value_5/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_5_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_9" + input: "compute_loss/clip_by_value_4/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_4_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_10_grad/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: "train_op/gradients/compute_loss/Slice_10_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_10_grad/stack/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: "train_op/gradients/compute_loss/Slice_10_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_10_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_10_grad/stack/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: "train_op/gradients/compute_loss/Slice_10_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_10/begin" + input: "train_op/gradients/compute_loss/Slice_10_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_10_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_10_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_10_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_10_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_10_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_10_grad/sub" + input: "compute_loss/Slice_10/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_10_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_10_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_10_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_10_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_10_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_10_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_10_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_10_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_10_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_3/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_10_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_15_grad/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: "train_op/gradients/compute_loss/Slice_15_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_15_grad/stack/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: "train_op/gradients/compute_loss/Slice_15_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_15_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_15_grad/stack/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: "train_op/gradients/compute_loss/Slice_15_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_15/begin" + input: "train_op/gradients/compute_loss/Slice_15_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_15_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_15_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_15_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_15_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_15_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_15_grad/sub" + input: "compute_loss/Slice_15/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_15_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_15_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_15_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_15_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_15_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_15_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_15_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_15_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_15_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_8/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_15_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_16_grad/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: "train_op/gradients/compute_loss/Slice_16_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_16_grad/stack/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: "train_op/gradients/compute_loss/Slice_16_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_16_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_16_grad/stack/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: "train_op/gradients/compute_loss/Slice_16_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_16/begin" + input: "train_op/gradients/compute_loss/Slice_16_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_16_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_16_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_16_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_16_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_16_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_16_grad/sub" + input: "compute_loss/Slice_16/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_16_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_16_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_16_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_16_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_16_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_16_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_16_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_16_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_16_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_7/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_16_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_169" + op: "AddN" + input: "train_op/gradients/compute_loss/Slice_21_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_24_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_22_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_23_grad/Pad" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Slice_21_grad/Pad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_37_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_37_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_37_grad/Shape" + input: "compute_loss/strided_slice_37/stack" + input: "compute_loss/strided_slice_37/stack_1" + input: "compute_loss/strided_slice_37/stack_2" + input: "train_op/gradients/AddN_169" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 5 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 5 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_1" + input: "compute_loss/clip_by_value_2/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_2_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Shape_2" + 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: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/zeros/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: 0.0 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/zeros" + op: "Fill" + input: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Shape_2" + input: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/LessEqual" + op: "LessEqual" + input: "compute_loss/Slice_2" + input: "compute_loss/clip_by_value_1/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Shape" + input: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Select" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Select_1" + op: "Select" + input: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/LessEqual" + input: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/zeros" + input: "train_op/gradients/compute_loss/clip_by_value_1_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Sum" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Select" + input: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Sum" + input: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Select_1" + input: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Sum_1" + input: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Reshape_1" +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Reshape" + input: "^train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Reshape_1" + input: "^train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_3_grad/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: "train_op/gradients/compute_loss/Slice_3_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_3_grad/stack/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: "train_op/gradients/compute_loss/Slice_3_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_3_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_3_grad/stack/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: "train_op/gradients/compute_loss/Slice_3_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_3/begin" + input: "train_op/gradients/compute_loss/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_3_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_3_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_3_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_3_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_3_grad/sub" + input: "compute_loss/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_3_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_3_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_3_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_3_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_3_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_3_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv1/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/icnv1/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv1/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/icnv1/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv1/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv1/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv1/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv1/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv1/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv1/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv1/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv1/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv1/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_8_grad/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: "train_op/gradients/compute_loss/Slice_8_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_8_grad/stack/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: "train_op/gradients/compute_loss/Slice_8_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_8_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_8_grad/stack/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: "train_op/gradients/compute_loss/Slice_8_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_8/begin" + input: "train_op/gradients/compute_loss/Slice_8_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_8_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_8_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_8_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_8_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_8_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_8_grad/sub" + input: "compute_loss/Slice_8/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_8_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_8_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_8_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_8_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_8_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_8_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_8_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_8_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_8_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_5/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_8_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_9_grad/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: "train_op/gradients/compute_loss/Slice_9_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_9_grad/stack/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: "train_op/gradients/compute_loss/Slice_9_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_9_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_9_grad/stack/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: "train_op/gradients/compute_loss/Slice_9_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_9/begin" + input: "train_op/gradients/compute_loss/Slice_9_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_9_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_9_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_9_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_9_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_9_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_9_grad/sub" + input: "compute_loss/Slice_9/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_9_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_9_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_9_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_9_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_9_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_9_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_9_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_9_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_9_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_4/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_9_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_170" + op: "AddN" + input: "train_op/gradients/compute_loss/Slice_14_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_17_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_15_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_16_grad/Pad" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Slice_14_grad/Pad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_33_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_33_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_33_grad/Shape" + input: "compute_loss/strided_slice_33/stack" + input: "compute_loss/strided_slice_33/stack_1" + input: "compute_loss/strided_slice_33/stack_2" + input: "train_op/gradients/AddN_170" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 5 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 5 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_1_grad/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: "train_op/gradients/compute_loss/Slice_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_1_grad/stack/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: "train_op/gradients/compute_loss/Slice_1_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_1_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_1_grad/stack/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: "train_op/gradients/compute_loss/Slice_1_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_1/begin" + input: "train_op/gradients/compute_loss/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_1_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_1_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_1_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_1_grad/sub" + input: "compute_loss/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_1_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_1_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_1_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_1_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_1_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_1_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_2/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_2_grad/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: "train_op/gradients/compute_loss/Slice_2_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_2_grad/stack/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: "train_op/gradients/compute_loss/Slice_2_grad/stack" + op: "Pack" + input: "train_op/gradients/compute_loss/Slice_2_grad/Rank" + input: "train_op/gradients/compute_loss/Slice_2_grad/stack/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: "train_op/gradients/compute_loss/Slice_2_grad/Reshape" + op: "Reshape" + input: "compute_loss/Slice_2/begin" + input: "train_op/gradients/compute_loss/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_2_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_2_grad/sub" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_2_grad/Shape_1" + input: "train_op/gradients/compute_loss/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_2_grad/sub_1" + op: "Sub" + input: "train_op/gradients/compute_loss/Slice_2_grad/sub" + input: "compute_loss/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/compute_loss/Slice_2_grad/sub_1" + input: "train_op/gradients/compute_loss/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_2_grad/concat" + op: "ConcatV2" + input: "train_op/gradients/compute_loss/Slice_2_grad/Reshape" + input: "train_op/gradients/compute_loss/Slice_2_grad/Reshape_1" + input: "train_op/gradients/compute_loss/Slice_2_grad/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 + } + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/Slice_2_grad/Pad" + op: "Pad" + input: "train_op/gradients/compute_loss/clip_by_value_1/Minimum_grad/tuple/control_dependency" + input: "train_op/gradients/compute_loss/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv1/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/concat_6" + input: "depth_net/icnv1/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv1/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/icnv1/Conv2D_grad/ShapeN" + input: "depth_net/icnv1/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/icnv1/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv1/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/concat_6" + input: "train_op/gradients/depth_prediction/depth_net/icnv1/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/icnv1/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv1/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/icnv1/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/icnv1/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv1/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv1/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/icnv1/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv1/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 17 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv1/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv1/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/icnv1/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv1/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_171" + op: "AddN" + input: "train_op/gradients/compute_loss/Slice_7_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_10_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_8_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_9_grad/Pad" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Slice_7_grad/Pad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_17_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_17_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_17_grad/Shape" + input: "compute_loss/strided_slice_17/stack" + input: "compute_loss/strided_slice_17/stack_1" + input: "compute_loss/strided_slice_17/stack_2" + input: "train_op/gradients/AddN_171" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 5 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 5 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "train_op/gradients/AddN_172" + op: "AddN" + input: "train_op/gradients/compute_loss/Slice_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_3_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_1_grad/Pad" + input: "train_op/gradients/compute_loss/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/Slice_grad/Pad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_13_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/compute_loss/strided_slice_13_grad/StridedSliceGrad" + op: "StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_13_grad/Shape" + input: "compute_loss/strided_slice_13/stack" + input: "compute_loss/strided_slice_13/stack_1" + input: "compute_loss/strided_slice_13/stack_2" + input: "train_op/gradients/AddN_172" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 6 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 5 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 5 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 2 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/mod" + op: "FloorMod" + input: "depth_prediction/depth_net/concat_6/axis" + input: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\020\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\200\000\000\000\240\001\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/mod" + input: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/Shape" + input: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/Slice" + op: "Slice" + input: "train_op/gradients/depth_prediction/depth_net/icnv1/Conv2D_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/ConcatOffset" + input: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/depth_prediction/depth_net/icnv1/Conv2D_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/ConcatOffset:1" + input: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/concat_6_grad/Slice" + input: "^train_op/gradients/depth_prediction/depth_net/concat_6_grad/Slice_1" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/Slice" + input: "^train_op/gradients/depth_prediction/depth_net/concat_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_6_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/Slice_1" + input: "^train_op/gradients/depth_prediction/depth_net/concat_6_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_6_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_173" + op: "AddN" + input: "train_op/gradients/compute_loss/strided_slice_77_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_73_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_57_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_53_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_37_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_33_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_17_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_13_grad/StridedSliceGrad" + attr { + key: "N" + value { + i: 8 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_77_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/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: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Shape" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Mul" + op: "Mul" + input: "train_op/gradients/AddN_173" + input: "pose_and_explainability_prediction/pose_exp_net/pose/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Sum" + op: "Sum" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Mul" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Sum" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Mul_1" + op: "Mul" + input: "pose_and_explainability_prediction/pose_exp_net/pose/mul/x" + input: "train_op/gradients/AddN_173" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Mul_1" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Sum_1" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Reshape" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Reshape_1" +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Reshape" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Reshape_1" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 6 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv1/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/tuple/control_dependency" + input: "depth_prediction/depth_net/upcnv1/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/ResizeBilinear_2_grad/ResizeBilinearGrad" + op: "ResizeBilinearGrad" + input: "train_op/gradients/depth_prediction/depth_net/concat_6_grad/tuple/control_dependency_1" + input: "depth_prediction/depth_net/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "align_corners" + value { + b: false + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Reshape_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\004\000\000\000\014\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Reshape_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/mul_grad/tuple/control_dependency_1" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 12 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv1/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/upcnv1/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv1/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv1/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv1/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv1/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv1/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv1/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv1/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv1/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv1/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv1/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv1/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_174" + op: "AddN" + input: "train_op/gradients/compute_loss/strided_slice_20_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_21_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_22_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_23_grad/StridedSliceGrad" + input: "train_op/gradients/depth_prediction/truediv_1_grad/tuple/control_dependency_1" + input: "train_op/gradients/depth_prediction/depth_net/ResizeBilinear_2_grad/ResizeBilinearGrad" + attr { + key: "N" + value { + i: 6 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_20_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_2_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_2_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/depth_prediction/depth_net/add_2_grad/Shape" + input: "train_op/gradients/depth_prediction/depth_net/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_2_grad/Sum" + op: "Sum" + input: "train_op/gradients/AddN_174" + input: "train_op/gradients/depth_prediction/depth_net/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_2_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/depth_prediction/depth_net/add_2_grad/Sum" + input: "train_op/gradients/depth_prediction/depth_net/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_2_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/AddN_174" + input: "train_op/gradients/depth_prediction/depth_net/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_2_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/depth_prediction/depth_net/add_2_grad/Sum_1" + input: "train_op/gradients/depth_prediction/depth_net/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/add_2_grad/Reshape" + input: "^train_op/gradients/depth_prediction/depth_net/add_2_grad/Reshape_1" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/add_2_grad/Reshape" + input: "^train_op/gradients/depth_prediction/depth_net/add_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/add_2_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/add_2_grad/Reshape_1" + input: "^train_op/gradients/depth_prediction/depth_net/add_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/add_2_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\001\000\000\000\004\000\000\000\014\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Size" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Shape" + } + } + } + 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: 4 + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/add" + op: "Add" + input: "pose_and_explainability_prediction/pose_exp_net/pose/Mean/reduction_indices" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Size" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Shape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/mod" + op: "FloorMod" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/add" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Size" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Shape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Shape_1" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Shape" + } + } + } + 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: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/range/start" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Shape" + } + } + } + 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: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/range/delta" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Shape" + } + } + } + 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: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/range" + op: "Range" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/range/start" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Size" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/range/delta" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Shape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Fill/value" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Shape" + } + } + } + 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: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Fill" + op: "Fill" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Shape_1" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Fill/value" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Shape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/DynamicStitch" + op: "DynamicStitch" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/range" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/mod" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Shape" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Fill" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Shape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Maximum/y" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Shape" + } + } + } + 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: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Maximum" + op: "Maximum" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/DynamicStitch" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Maximum/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Shape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/floordiv" + op: "FloorDiv" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Shape" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Maximum" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Shape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Reshape_grad/Reshape" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/DynamicStitch" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Tile" + op: "Tile" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Reshape" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/floordiv" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/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: 4.0 + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/truediv" + op: "RealDiv" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Tile" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 12 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv1/conv2d_transpose_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\020\000\000\000 \000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv1/conv2d_transpose_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "train_op/gradients/depth_prediction/depth_net/upcnv1/BiasAdd_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/upcnv1/conv2d_transpose_grad/Shape" + input: "depth_prediction/depth_net/icnv2/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv1/conv2d_transpose_grad/Conv2D" + op: "Conv2D" + input: "train_op/gradients/depth_prediction/depth_net/upcnv1/BiasAdd_grad/tuple/control_dependency" + input: "depth_net/upcnv1/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv1/conv2d_transpose_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv1/conv2d_transpose_grad/Conv2D" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv1/conv2d_transpose_grad/Conv2DBackpropFilter" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv1/conv2d_transpose_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv1/conv2d_transpose_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv1/conv2d_transpose_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv1/conv2d_transpose_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv1/conv2d_transpose_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv1/conv2d_transpose_grad/Conv2D" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv1/conv2d_transpose_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv1/conv2d_transpose_grad/Conv2D" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/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: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/Shape" + input: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/Mul" + op: "Mul" + input: "train_op/gradients/depth_prediction/depth_net/add_2_grad/tuple/control_dependency" + input: "depth_prediction/depth_net/disp2/Sigmoid" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/Sum" + op: "Sum" + input: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/Mul" + input: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/Sum" + input: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/Mul_1" + op: "Mul" + input: "depth_prediction/depth_net/mul_2/x" + input: "train_op/gradients/depth_prediction/depth_net/add_2_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/Mul_1" + input: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/Sum_1" + input: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/mul_2_grad/Reshape" + input: "^train_op/gradients/depth_prediction/depth_net/mul_2_grad/Reshape_1" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/Reshape" + input: "^train_op/gradients/depth_prediction/depth_net/mul_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/mul_2_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/Reshape_1" + input: "^train_op/gradients/depth_prediction/depth_net/mul_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/mul_2_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/truediv" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 12 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/truediv" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/BiasAdd_grad/BiasAddGrad" +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/truediv" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/Mean_grad/truediv" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 12 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 12 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp2/Sigmoid_grad/SigmoidGrad" + op: "SigmoidGrad" + input: "depth_prediction/depth_net/disp2/Sigmoid" + input: "train_op/gradients/depth_prediction/depth_net/mul_2_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Relu" + input: "pose_exp_net/pose/pred/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D_grad/ShapeN" + input: "pose_exp_net/pose/pred/weights/read" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Relu" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp2/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/disp2/Sigmoid_grad/SigmoidGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp2/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/disp2/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/disp2/Sigmoid_grad/SigmoidGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp2/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/disp2/Sigmoid_grad/SigmoidGrad" + input: "^train_op/gradients/depth_prediction/depth_net/disp2/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/disp2/Sigmoid_grad/SigmoidGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp2/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/disp2/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/disp2/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/disp2/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D_grad/tuple/control_dependency" + input: "pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp2/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/icnv2/Relu" + input: "depth_net/disp2/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp2/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/disp2/Conv2D_grad/ShapeN" + input: "depth_net/disp2/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/disp2/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp2/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/icnv2/Relu" + input: "train_op/gradients/depth_prediction/depth_net/disp2/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/disp2/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp2/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/disp2/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/disp2/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp2/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/disp2/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/disp2/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/disp2/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp2/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/disp2/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/disp2/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/disp2/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Relu_grad/ReluGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_175" + op: "AddN" + input: "train_op/gradients/depth_prediction/depth_net/upcnv1/conv2d_transpose_grad/tuple/control_dependency_1" + input: "train_op/gradients/depth_prediction/depth_net/disp2/Conv2D_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv1/conv2d_transpose_grad/Conv2D" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv2/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/AddN_175" + input: "depth_prediction/depth_net/icnv2/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Relu" + input: "pose_exp_net/pose/cnv7/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D_grad/ShapeN" + input: "pose_exp_net/pose/cnv7/weights/read" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Relu" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv2/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/icnv2/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv2/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/icnv2/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv2/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv2/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv2/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv2/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv2/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv2/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv2/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv2/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv2/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D_grad/tuple/control_dependency" + input: "pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/concat_5" + input: "depth_net/icnv2/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/ShapeN" + input: "depth_net/icnv2/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/icnv2/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/concat_5" + input: "train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/icnv2/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 65 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Relu_grad/ReluGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/mod" + op: "FloorMod" + input: "depth_prediction/depth_net/concat_5/axis" + input: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000 \000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000 \000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000@\000\000\000\320\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/mod" + input: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/Shape" + input: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/Shape_1" + input: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/Shape_2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/Slice" + op: "Slice" + input: "train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/ConcatOffset" + input: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/ConcatOffset:1" + input: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/ConcatOffset:2" + input: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/Shape_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/concat_5_grad/Slice" + input: "^train_op/gradients/depth_prediction/depth_net/concat_5_grad/Slice_1" + input: "^train_op/gradients/depth_prediction/depth_net/concat_5_grad/Slice_2" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/Slice" + input: "^train_op/gradients/depth_prediction/depth_net/concat_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_5_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/Slice_1" + input: "^train_op/gradients/depth_prediction/depth_net/concat_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_5_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/Slice_2" + input: "^train_op/gradients/depth_prediction/depth_net/concat_5_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_5_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "pose_and_explainability_prediction/pose_exp_net/cnv5/Relu" + input: "pose_exp_net/pose/cnv6/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D_grad/ShapeN" + input: "pose_exp_net/pose/cnv6/weights/read" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "pose_and_explainability_prediction/pose_exp_net/cnv5/Relu" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv2/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/tuple/control_dependency" + input: "depth_prediction/depth_net/upcnv2/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/ResizeBilinear_1_grad/ResizeBilinearGrad" + op: "ResizeBilinearGrad" + input: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/tuple/control_dependency_2" + input: "depth_prediction/depth_net/add_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "align_corners" + value { + b: false + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D_grad/tuple/control_dependency" + input: "pose_and_explainability_prediction/pose_exp_net/cnv5/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv2/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/upcnv2/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv2/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv2/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv2/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv2/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv2/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv2/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv2/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv2/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv2/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv2/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv2/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_176" + op: "AddN" + input: "train_op/gradients/compute_loss/strided_slice_40_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_41_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_42_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_43_grad/StridedSliceGrad" + input: "train_op/gradients/depth_prediction/truediv_2_grad/tuple/control_dependency_1" + input: "train_op/gradients/depth_prediction/depth_net/ResizeBilinear_1_grad/ResizeBilinearGrad" + attr { + key: "N" + value { + i: 6 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_40_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/depth_prediction/depth_net/add_1_grad/Shape" + input: "train_op/gradients/depth_prediction/depth_net/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/AddN_176" + input: "train_op/gradients/depth_prediction/depth_net/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/depth_prediction/depth_net/add_1_grad/Sum" + input: "train_op/gradients/depth_prediction/depth_net/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/AddN_176" + input: "train_op/gradients/depth_prediction/depth_net/add_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/depth_prediction/depth_net/add_1_grad/Sum_1" + input: "train_op/gradients/depth_prediction/depth_net/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/add_1_grad/Reshape" + input: "^train_op/gradients/depth_prediction/depth_net/add_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/add_1_grad/Reshape" + input: "^train_op/gradients/depth_prediction/depth_net/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/add_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/add_1_grad/Reshape_1" + input: "^train_op/gradients/depth_prediction/depth_net/add_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/add_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Relu_grad/ReluGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv2/conv2d_transpose_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000 \000\000\000@\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv2/conv2d_transpose_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "train_op/gradients/depth_prediction/depth_net/upcnv2/BiasAdd_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/upcnv2/conv2d_transpose_grad/Shape" + input: "depth_prediction/depth_net/icnv3/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv2/conv2d_transpose_grad/Conv2D" + op: "Conv2D" + input: "train_op/gradients/depth_prediction/depth_net/upcnv2/BiasAdd_grad/tuple/control_dependency" + input: "depth_net/upcnv2/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv2/conv2d_transpose_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv2/conv2d_transpose_grad/Conv2D" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv2/conv2d_transpose_grad/Conv2DBackpropFilter" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv2/conv2d_transpose_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv2/conv2d_transpose_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv2/conv2d_transpose_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv2/conv2d_transpose_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv2/conv2d_transpose_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv2/conv2d_transpose_grad/Conv2D" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv2/conv2d_transpose_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv2/conv2d_transpose_grad/Conv2D" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/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: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/Shape" + input: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/Mul" + op: "Mul" + input: "train_op/gradients/depth_prediction/depth_net/add_1_grad/tuple/control_dependency" + input: "depth_prediction/depth_net/disp3/Sigmoid" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/Sum" + op: "Sum" + input: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/Mul" + input: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/Sum" + input: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/Mul_1" + op: "Mul" + input: "depth_prediction/depth_net/mul_1/x" + input: "train_op/gradients/depth_prediction/depth_net/add_1_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/Mul_1" + input: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/Sum_1" + input: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/mul_1_grad/Reshape" + input: "^train_op/gradients/depth_prediction/depth_net/mul_1_grad/Reshape_1" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/Reshape" + input: "^train_op/gradients/depth_prediction/depth_net/mul_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/mul_1_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/Reshape_1" + input: "^train_op/gradients/depth_prediction/depth_net/mul_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/mul_1_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "pose_and_explainability_prediction/pose_exp_net/cnv4/Relu" + input: "pose_exp_net/cnv5/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D_grad/ShapeN" + input: "pose_exp_net/cnv5/weights/read" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "pose_and_explainability_prediction/pose_exp_net/cnv4/Relu" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp3/Sigmoid_grad/SigmoidGrad" + op: "SigmoidGrad" + input: "depth_prediction/depth_net/disp3/Sigmoid" + input: "train_op/gradients/depth_prediction/depth_net/mul_1_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D_grad/tuple/control_dependency" + input: "pose_and_explainability_prediction/pose_exp_net/cnv4/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp3/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/disp3/Sigmoid_grad/SigmoidGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp3/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/disp3/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/disp3/Sigmoid_grad/SigmoidGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp3/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/disp3/Sigmoid_grad/SigmoidGrad" + input: "^train_op/gradients/depth_prediction/depth_net/disp3/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/disp3/Sigmoid_grad/SigmoidGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp3/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/disp3/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/disp3/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/disp3/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Relu_grad/ReluGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp3/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/icnv3/Relu" + input: "depth_net/disp3/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp3/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/disp3/Conv2D_grad/ShapeN" + input: "depth_net/disp3/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/disp3/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp3/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/icnv3/Relu" + input: "train_op/gradients/depth_prediction/depth_net/disp3/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/disp3/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp3/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/disp3/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/disp3/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp3/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/disp3/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/disp3/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/disp3/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp3/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/disp3/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/disp3/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/disp3/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "pose_and_explainability_prediction/pose_exp_net/cnv3/Relu" + input: "pose_exp_net/cnv4/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D_grad/ShapeN" + input: "pose_exp_net/cnv4/weights/read" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "pose_and_explainability_prediction/pose_exp_net/cnv3/Relu" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_177" + op: "AddN" + input: "train_op/gradients/depth_prediction/depth_net/upcnv2/conv2d_transpose_grad/tuple/control_dependency_1" + input: "train_op/gradients/depth_prediction/depth_net/disp3/Conv2D_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv2/conv2d_transpose_grad/Conv2D" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv3/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/AddN_177" + input: "depth_prediction/depth_net/icnv3/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D_grad/tuple/control_dependency" + input: "pose_and_explainability_prediction/pose_exp_net/cnv3/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv3/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/icnv3/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv3/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/icnv3/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv3/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv3/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv3/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv3/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv3/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv3/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv3/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv3/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv3/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Relu_grad/ReluGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/concat_4" + input: "depth_net/icnv3/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/ShapeN" + input: "depth_net/icnv3/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/icnv3/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/concat_4" + input: "train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/icnv3/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 129 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "pose_and_explainability_prediction/pose_exp_net/cnv2/Relu" + input: "pose_exp_net/cnv3/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D_grad/ShapeN" + input: "pose_exp_net/cnv3/weights/read" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "pose_and_explainability_prediction/pose_exp_net/cnv2/Relu" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/mod" + op: "FloorMod" + input: "depth_prediction/depth_net/concat_4/axis" + input: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000@\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000@\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000 \000\000\000h\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/mod" + input: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/Shape" + input: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/Shape_1" + input: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/Shape_2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/Slice" + op: "Slice" + input: "train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/ConcatOffset" + input: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/ConcatOffset:1" + input: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/Slice_2" + op: "Slice" + input: "train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/ConcatOffset:2" + input: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/Shape_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/concat_4_grad/Slice" + input: "^train_op/gradients/depth_prediction/depth_net/concat_4_grad/Slice_1" + input: "^train_op/gradients/depth_prediction/depth_net/concat_4_grad/Slice_2" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/Slice" + input: "^train_op/gradients/depth_prediction/depth_net/concat_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_4_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/Slice_1" + input: "^train_op/gradients/depth_prediction/depth_net/concat_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_4_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/tuple/control_dependency_2" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/Slice_2" + input: "^train_op/gradients/depth_prediction/depth_net/concat_4_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_4_grad/Slice_2" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D_grad/tuple/control_dependency" + input: "pose_and_explainability_prediction/pose_exp_net/cnv2/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv3/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/tuple/control_dependency" + input: "depth_prediction/depth_net/upcnv3/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/ResizeBilinear_grad/ResizeBilinearGrad" + op: "ResizeBilinearGrad" + input: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/tuple/control_dependency_2" + input: "depth_prediction/depth_net/add" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "align_corners" + value { + b: false + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Relu_grad/ReluGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv3/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/upcnv3/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv3/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv3/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv3/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv3/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv3/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv3/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv3/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv3/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv3/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv3/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv3/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_178" + op: "AddN" + input: "train_op/gradients/compute_loss/strided_slice_60_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_61_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_62_grad/StridedSliceGrad" + input: "train_op/gradients/compute_loss/strided_slice_63_grad/StridedSliceGrad" + input: "train_op/gradients/depth_prediction/truediv_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/depth_prediction/depth_net/ResizeBilinear_grad/ResizeBilinearGrad" + attr { + key: "N" + value { + i: 6 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/compute_loss/strided_slice_60_grad/StridedSliceGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/depth_prediction/depth_net/add_grad/Shape" + input: "train_op/gradients/depth_prediction/depth_net/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_grad/Sum" + op: "Sum" + input: "train_op/gradients/AddN_178" + input: "train_op/gradients/depth_prediction/depth_net/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/depth_prediction/depth_net/add_grad/Sum" + input: "train_op/gradients/depth_prediction/depth_net/add_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/AddN_178" + input: "train_op/gradients/depth_prediction/depth_net/add_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/depth_prediction/depth_net/add_grad/Sum_1" + input: "train_op/gradients/depth_prediction/depth_net/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/add_grad/Reshape" + input: "^train_op/gradients/depth_prediction/depth_net/add_grad/Reshape_1" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/add_grad/Reshape" + input: "^train_op/gradients/depth_prediction/depth_net/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/add_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/add_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/add_grad/Reshape_1" + input: "^train_op/gradients/depth_prediction/depth_net/add_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/add_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "pose_and_explainability_prediction/pose_exp_net/cnv1/Relu" + input: "pose_exp_net/cnv2/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D_grad/ShapeN" + input: "pose_exp_net/cnv2/weights/read" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "pose_and_explainability_prediction/pose_exp_net/cnv1/Relu" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv3/conv2d_transpose_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000@\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv3/conv2d_transpose_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "train_op/gradients/depth_prediction/depth_net/upcnv3/BiasAdd_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/upcnv3/conv2d_transpose_grad/Shape" + input: "depth_prediction/depth_net/icnv4/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv3/conv2d_transpose_grad/Conv2D" + op: "Conv2D" + input: "train_op/gradients/depth_prediction/depth_net/upcnv3/BiasAdd_grad/tuple/control_dependency" + input: "depth_net/upcnv3/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv3/conv2d_transpose_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv3/conv2d_transpose_grad/Conv2D" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv3/conv2d_transpose_grad/Conv2DBackpropFilter" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv3/conv2d_transpose_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv3/conv2d_transpose_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv3/conv2d_transpose_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv3/conv2d_transpose_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv3/conv2d_transpose_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv3/conv2d_transpose_grad/Conv2D" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv3/conv2d_transpose_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv3/conv2d_transpose_grad/Conv2D" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_grad/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: "train_op/gradients/depth_prediction/depth_net/mul_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "train_op/gradients/depth_prediction/depth_net/mul_grad/Shape" + input: "train_op/gradients/depth_prediction/depth_net/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_grad/Mul" + op: "Mul" + input: "train_op/gradients/depth_prediction/depth_net/add_grad/tuple/control_dependency" + input: "depth_prediction/depth_net/disp4/Sigmoid" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_grad/Sum" + op: "Sum" + input: "train_op/gradients/depth_prediction/depth_net/mul_grad/Mul" + input: "train_op/gradients/depth_prediction/depth_net/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_grad/Reshape" + op: "Reshape" + input: "train_op/gradients/depth_prediction/depth_net/mul_grad/Sum" + input: "train_op/gradients/depth_prediction/depth_net/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_grad/Mul_1" + op: "Mul" + input: "depth_prediction/depth_net/mul/x" + input: "train_op/gradients/depth_prediction/depth_net/add_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_grad/Sum_1" + op: "Sum" + input: "train_op/gradients/depth_prediction/depth_net/mul_grad/Mul_1" + input: "train_op/gradients/depth_prediction/depth_net/mul_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_grad/Reshape_1" + op: "Reshape" + input: "train_op/gradients/depth_prediction/depth_net/mul_grad/Sum_1" + input: "train_op/gradients/depth_prediction/depth_net/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/mul_grad/Reshape" + input: "^train_op/gradients/depth_prediction/depth_net/mul_grad/Reshape_1" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/mul_grad/Reshape" + input: "^train_op/gradients/depth_prediction/depth_net/mul_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/mul_grad/Reshape" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/mul_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/mul_grad/Reshape_1" + input: "^train_op/gradients/depth_prediction/depth_net/mul_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/mul_grad/Reshape_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D_grad/tuple/control_dependency" + input: "pose_and_explainability_prediction/pose_exp_net/cnv1/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp4/Sigmoid_grad/SigmoidGrad" + op: "SigmoidGrad" + input: "depth_prediction/depth_net/disp4/Sigmoid" + input: "train_op/gradients/depth_prediction/depth_net/mul_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Relu_grad/ReluGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp4/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/disp4/Sigmoid_grad/SigmoidGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp4/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/disp4/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/disp4/Sigmoid_grad/SigmoidGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp4/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/disp4/Sigmoid_grad/SigmoidGrad" + input: "^train_op/gradients/depth_prediction/depth_net/disp4/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/disp4/Sigmoid_grad/SigmoidGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp4/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/disp4/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/disp4/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/disp4/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "pose_and_explainability_prediction/concat" + input: "pose_exp_net/cnv1/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Conv2D_grad/ShapeN" + input: "pose_exp_net/cnv1/weights/read" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "pose_and_explainability_prediction/concat" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 9 + } + } + } + } + } +} +node { + name: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp4/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/icnv4/Relu" + input: "depth_net/disp4/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp4/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/disp4/Conv2D_grad/ShapeN" + input: "depth_net/disp4/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/disp4/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp4/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/icnv4/Relu" + input: "train_op/gradients/depth_prediction/depth_net/disp4/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/disp4/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp4/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/disp4/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/disp4/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp4/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/disp4/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/disp4/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/disp4/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/disp4/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/disp4/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/disp4/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/disp4/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_179" + op: "AddN" + input: "train_op/gradients/depth_prediction/depth_net/upcnv3/conv2d_transpose_grad/tuple/control_dependency_1" + input: "train_op/gradients/depth_prediction/depth_net/disp4/Conv2D_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv3/conv2d_transpose_grad/Conv2D" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv4/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/AddN_179" + input: "depth_prediction/depth_net/icnv4/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv4/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/icnv4/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv4/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/icnv4/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv4/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv4/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv4/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv4/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv4/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv4/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv4/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv4/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv4/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv4/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/concat_3" + input: "depth_net/icnv4/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv4/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/icnv4/Conv2D_grad/ShapeN" + input: "depth_net/icnv4/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/icnv4/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv4/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/concat_3" + input: "train_op/gradients/depth_prediction/depth_net/icnv4/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/icnv4/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv4/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/icnv4/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/icnv4/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv4/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv4/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/icnv4/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv4/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv4/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv4/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/icnv4/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv4/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/mod" + op: "FloorMod" + input: "depth_prediction/depth_net/concat_3/axis" + input: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\020\000\000\0004\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/mod" + input: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/Shape" + input: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/Slice" + op: "Slice" + input: "train_op/gradients/depth_prediction/depth_net/icnv4/Conv2D_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/ConcatOffset" + input: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/depth_prediction/depth_net/icnv4/Conv2D_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/ConcatOffset:1" + input: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/concat_3_grad/Slice" + input: "^train_op/gradients/depth_prediction/depth_net/concat_3_grad/Slice_1" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/Slice" + input: "^train_op/gradients/depth_prediction/depth_net/concat_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_3_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/Slice_1" + input: "^train_op/gradients/depth_prediction/depth_net/concat_3_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_3_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv4/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/tuple/control_dependency" + input: "depth_prediction/depth_net/upcnv4/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv4/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/upcnv4/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv4/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv4/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv4/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv4/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv4/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv4/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv4/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv4/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv4/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv4/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv4/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv4/conv2d_transpose_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\000\001\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv4/conv2d_transpose_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "train_op/gradients/depth_prediction/depth_net/upcnv4/BiasAdd_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/upcnv4/conv2d_transpose_grad/Shape" + input: "depth_prediction/depth_net/icnv5/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv4/conv2d_transpose_grad/Conv2D" + op: "Conv2D" + input: "train_op/gradients/depth_prediction/depth_net/upcnv4/BiasAdd_grad/tuple/control_dependency" + input: "depth_net/upcnv4/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv4/conv2d_transpose_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv4/conv2d_transpose_grad/Conv2D" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv4/conv2d_transpose_grad/Conv2DBackpropFilter" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv4/conv2d_transpose_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv4/conv2d_transpose_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv4/conv2d_transpose_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv4/conv2d_transpose_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv4/conv2d_transpose_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv4/conv2d_transpose_grad/Conv2D" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv4/conv2d_transpose_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv4/conv2d_transpose_grad/Conv2D" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv5/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/depth_prediction/depth_net/upcnv4/conv2d_transpose_grad/tuple/control_dependency_1" + input: "depth_prediction/depth_net/icnv5/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv5/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/icnv5/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv5/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/icnv5/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv5/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv5/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv5/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv5/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv5/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv5/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv5/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv5/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv5/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv5/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/concat_2" + input: "depth_net/icnv5/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv5/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/icnv5/Conv2D_grad/ShapeN" + input: "depth_net/icnv5/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/icnv5/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv5/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/concat_2" + input: "train_op/gradients/depth_prediction/depth_net/icnv5/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/icnv5/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv5/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/icnv5/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/icnv5/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv5/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv5/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/icnv5/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv5/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv5/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv5/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/icnv5/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv5/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/mod" + op: "FloorMod" + input: "depth_prediction/depth_net/concat_2/axis" + input: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\010\000\000\000\032\000\000\000\000\001\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\010\000\000\000\032\000\000\000\000\001\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/mod" + input: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/Shape" + input: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/Slice" + op: "Slice" + input: "train_op/gradients/depth_prediction/depth_net/icnv5/Conv2D_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/ConcatOffset" + input: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/depth_prediction/depth_net/icnv5/Conv2D_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/ConcatOffset:1" + input: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/concat_2_grad/Slice" + input: "^train_op/gradients/depth_prediction/depth_net/concat_2_grad/Slice_1" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/Slice" + input: "^train_op/gradients/depth_prediction/depth_net/concat_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_2_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/Slice_1" + input: "^train_op/gradients/depth_prediction/depth_net/concat_2_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_2_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv5/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/tuple/control_dependency" + input: "depth_prediction/depth_net/upcnv5/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv5/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/upcnv5/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv5/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv5/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv5/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv5/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv5/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv5/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv5/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv5/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv5/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv5/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv5/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv5/conv2d_transpose_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\002\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv5/conv2d_transpose_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "train_op/gradients/depth_prediction/depth_net/upcnv5/BiasAdd_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/upcnv5/conv2d_transpose_grad/Shape" + input: "depth_prediction/depth_net/icnv6/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv5/conv2d_transpose_grad/Conv2D" + op: "Conv2D" + input: "train_op/gradients/depth_prediction/depth_net/upcnv5/BiasAdd_grad/tuple/control_dependency" + input: "depth_net/upcnv5/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv5/conv2d_transpose_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv5/conv2d_transpose_grad/Conv2D" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv5/conv2d_transpose_grad/Conv2DBackpropFilter" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv5/conv2d_transpose_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv5/conv2d_transpose_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv5/conv2d_transpose_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv5/conv2d_transpose_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv5/conv2d_transpose_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv5/conv2d_transpose_grad/Conv2D" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv5/conv2d_transpose_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv5/conv2d_transpose_grad/Conv2D" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv6/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/depth_prediction/depth_net/upcnv5/conv2d_transpose_grad/tuple/control_dependency_1" + input: "depth_prediction/depth_net/icnv6/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv6/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/icnv6/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv6/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/icnv6/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv6/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv6/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv6/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv6/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv6/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv6/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv6/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv6/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv6/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv6/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/concat_1" + input: "depth_net/icnv6/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv6/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/icnv6/Conv2D_grad/ShapeN" + input: "depth_net/icnv6/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/icnv6/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv6/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/concat_1" + input: "train_op/gradients/depth_prediction/depth_net/icnv6/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/icnv6/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv6/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/icnv6/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/icnv6/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv6/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv6/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/icnv6/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv6/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 1024 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv6/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv6/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/icnv6/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv6/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/mod" + op: "FloorMod" + input: "depth_prediction/depth_net/concat_1/axis" + input: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\r\000\000\000\000\002\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\004\000\000\000\r\000\000\000\000\002\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/mod" + input: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/Shape" + input: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/Slice" + op: "Slice" + input: "train_op/gradients/depth_prediction/depth_net/icnv6/Conv2D_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/ConcatOffset" + input: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/depth_prediction/depth_net/icnv6/Conv2D_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/ConcatOffset:1" + input: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/concat_1_grad/Slice" + input: "^train_op/gradients/depth_prediction/depth_net/concat_1_grad/Slice_1" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/Slice" + input: "^train_op/gradients/depth_prediction/depth_net/concat_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_1_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/Slice_1" + input: "^train_op/gradients/depth_prediction/depth_net/concat_1_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_1_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/ResizeNearestNeighbor_1_grad/ResizeNearestNeighborGrad/size" + 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: "\004\000\000\000\016\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/ResizeNearestNeighbor_1_grad/ResizeNearestNeighborGrad" + op: "ResizeNearestNeighborGrad" + input: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/ResizeNearestNeighbor_1_grad/ResizeNearestNeighborGrad/size" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 14 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "align_corners" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv6/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/depth_prediction/depth_net/ResizeNearestNeighbor_1_grad/ResizeNearestNeighborGrad" + input: "depth_prediction/depth_net/upcnv6/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 14 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv6/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/upcnv6/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv6/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv6/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv6/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv6/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv6/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv6/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv6/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 14 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv6/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv6/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv6/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv6/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv6/conv2d_transpose_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv6/conv2d_transpose_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "train_op/gradients/depth_prediction/depth_net/upcnv6/BiasAdd_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/upcnv6/conv2d_transpose_grad/Shape" + input: "depth_prediction/depth_net/icnv7/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv6/conv2d_transpose_grad/Conv2D" + op: "Conv2D" + input: "train_op/gradients/depth_prediction/depth_net/upcnv6/BiasAdd_grad/tuple/control_dependency" + input: "depth_net/upcnv6/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv6/conv2d_transpose_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv6/conv2d_transpose_grad/Conv2D" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv6/conv2d_transpose_grad/Conv2DBackpropFilter" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv6/conv2d_transpose_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv6/conv2d_transpose_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv6/conv2d_transpose_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv6/conv2d_transpose_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv6/conv2d_transpose_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv6/conv2d_transpose_grad/Conv2D" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv6/conv2d_transpose_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv6/conv2d_transpose_grad/Conv2D" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv7/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/depth_prediction/depth_net/upcnv6/conv2d_transpose_grad/tuple/control_dependency_1" + input: "depth_prediction/depth_net/icnv7/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv7/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/icnv7/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv7/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/icnv7/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv7/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv7/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv7/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv7/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv7/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv7/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv7/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/icnv7/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv7/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv7/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/concat" + input: "depth_net/icnv7/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv7/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/icnv7/Conv2D_grad/ShapeN" + input: "depth_net/icnv7/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/icnv7/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv7/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/concat" + input: "train_op/gradients/depth_prediction/depth_net/icnv7/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/icnv7/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv7/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/icnv7/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/icnv7/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv7/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv7/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/icnv7/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv7/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 1024 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/icnv7/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/icnv7/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/icnv7/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/icnv7/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_grad/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: 4 + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_grad/mod" + op: "FloorMod" + input: "depth_prediction/depth_net/concat/axis" + input: "train_op/gradients/depth_prediction/depth_net/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\007\000\000\000\000\002\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_grad/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\004\000\000\000\002\000\000\000\007\000\000\000\000\002\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "train_op/gradients/depth_prediction/depth_net/concat_grad/mod" + input: "train_op/gradients/depth_prediction/depth_net/concat_grad/Shape" + input: "train_op/gradients/depth_prediction/depth_net/concat_grad/Shape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_grad/Slice" + op: "Slice" + input: "train_op/gradients/depth_prediction/depth_net/icnv7/Conv2D_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/concat_grad/ConcatOffset" + input: "train_op/gradients/depth_prediction/depth_net/concat_grad/Shape" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_grad/Slice_1" + op: "Slice" + input: "train_op/gradients/depth_prediction/depth_net/icnv7/Conv2D_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/concat_grad/ConcatOffset:1" + input: "train_op/gradients/depth_prediction/depth_net/concat_grad/Shape_1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/concat_grad/Slice" + input: "^train_op/gradients/depth_prediction/depth_net/concat_grad/Slice_1" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/concat_grad/Slice" + input: "^train_op/gradients/depth_prediction/depth_net/concat_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_grad/Slice" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/concat_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/concat_grad/Slice_1" + input: "^train_op/gradients/depth_prediction/depth_net/concat_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/ResizeNearestNeighbor_grad/ResizeNearestNeighborGrad/size" + 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: "\002\000\000\000\010\000\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/ResizeNearestNeighbor_grad/ResizeNearestNeighborGrad" + op: "ResizeNearestNeighborGrad" + input: "train_op/gradients/depth_prediction/depth_net/concat_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/ResizeNearestNeighbor_grad/ResizeNearestNeighborGrad/size" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 8 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "align_corners" + value { + b: false + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv7/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/depth_prediction/depth_net/ResizeNearestNeighbor_grad/ResizeNearestNeighborGrad" + input: "depth_prediction/depth_net/upcnv7/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 8 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv7/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/upcnv7/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv7/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv7/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv7/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv7/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv7/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv7/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv7/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 8 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv7/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv7/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv7/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv7/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv7/conv2d_transpose_grad/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv7/conv2d_transpose_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "train_op/gradients/depth_prediction/depth_net/upcnv7/BiasAdd_grad/tuple/control_dependency" + input: "train_op/gradients/depth_prediction/depth_net/upcnv7/conv2d_transpose_grad/Shape" + input: "depth_prediction/depth_net/cnv7b/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv7/conv2d_transpose_grad/Conv2D" + op: "Conv2D" + input: "train_op/gradients/depth_prediction/depth_net/upcnv7/BiasAdd_grad/tuple/control_dependency" + input: "depth_net/upcnv7/weights/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv7/conv2d_transpose_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv7/conv2d_transpose_grad/Conv2D" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv7/conv2d_transpose_grad/Conv2DBackpropFilter" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv7/conv2d_transpose_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv7/conv2d_transpose_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv7/conv2d_transpose_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv7/conv2d_transpose_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/upcnv7/conv2d_transpose_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/upcnv7/conv2d_transpose_grad/Conv2D" + input: "^train_op/gradients/depth_prediction/depth_net/upcnv7/conv2d_transpose_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/upcnv7/conv2d_transpose_grad/Conv2D" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7b/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/depth_prediction/depth_net/upcnv7/conv2d_transpose_grad/tuple/control_dependency_1" + input: "depth_prediction/depth_net/cnv7b/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7b/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv7b/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7b/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv7b/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv7b/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7b/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv7b/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv7b/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv7b/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7b/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv7b/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv7b/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv7b/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7b/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/cnv7/Relu" + input: "depth_net/cnv7b/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7b/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/cnv7b/Conv2D_grad/ShapeN" + input: "depth_net/cnv7b/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/cnv7b/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7b/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/cnv7/Relu" + input: "train_op/gradients/depth_prediction/depth_net/cnv7b/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/cnv7b/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7b/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv7b/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv7b/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7b/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv7b/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/cnv7b/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv7b/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7b/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv7b/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv7b/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv7b/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv7b/Conv2D_grad/tuple/control_dependency" + input: "depth_prediction/depth_net/cnv7/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv7/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv7/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv7/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv7/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv7/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv7/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv7/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv7/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv7/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/cnv6b/Relu" + input: "depth_net/cnv7/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/cnv7/Conv2D_grad/ShapeN" + input: "depth_net/cnv7/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/cnv7/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/cnv6b/Relu" + input: "train_op/gradients/depth_prediction/depth_net/cnv7/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/cnv7/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv7/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv7/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv7/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/cnv7/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv7/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv7/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv7/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv7/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv7/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_180" + op: "AddN" + input: "train_op/gradients/depth_prediction/depth_net/concat_grad/tuple/control_dependency_1" + input: "train_op/gradients/depth_prediction/depth_net/cnv7/Conv2D_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6b/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/AddN_180" + input: "depth_prediction/depth_net/cnv6b/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6b/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv6b/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6b/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv6b/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv6b/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6b/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv6b/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv6b/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv6b/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6b/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv6b/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv6b/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv6b/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6b/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/cnv6/Relu" + input: "depth_net/cnv6b/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6b/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/cnv6b/Conv2D_grad/ShapeN" + input: "depth_net/cnv6b/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/cnv6b/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6b/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/cnv6/Relu" + input: "train_op/gradients/depth_prediction/depth_net/cnv6b/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/cnv6b/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6b/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv6b/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv6b/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6b/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv6b/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/cnv6b/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv6b/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6b/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv6b/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv6b/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv6b/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv6b/Conv2D_grad/tuple/control_dependency" + input: "depth_prediction/depth_net/cnv6/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv6/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv6/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv6/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv6/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv6/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv6/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + dim { + size: 7 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv6/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv6/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv6/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/cnv5b/Relu" + input: "depth_net/cnv6/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/cnv6/Conv2D_grad/ShapeN" + input: "depth_net/cnv6/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/cnv6/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/cnv5b/Relu" + input: "train_op/gradients/depth_prediction/depth_net/cnv6/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/cnv6/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv6/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv6/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv6/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/cnv6/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv6/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv6/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv6/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv6/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv6/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_181" + op: "AddN" + input: "train_op/gradients/depth_prediction/depth_net/concat_1_grad/tuple/control_dependency_1" + input: "train_op/gradients/depth_prediction/depth_net/cnv6/Conv2D_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_1_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5b/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/AddN_181" + input: "depth_prediction/depth_net/cnv5b/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5b/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv5b/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5b/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv5b/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv5b/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5b/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv5b/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv5b/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv5b/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5b/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv5b/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv5b/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv5b/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5b/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/cnv5/Relu" + input: "depth_net/cnv5b/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5b/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/cnv5b/Conv2D_grad/ShapeN" + input: "depth_net/cnv5b/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/cnv5b/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5b/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/cnv5/Relu" + input: "train_op/gradients/depth_prediction/depth_net/cnv5b/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/cnv5b/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5b/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv5b/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv5b/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5b/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv5b/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/cnv5b/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv5b/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5b/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv5b/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv5b/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv5b/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv5b/Conv2D_grad/tuple/control_dependency" + input: "depth_prediction/depth_net/cnv5/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv5/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv5/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv5/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv5/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv5/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv5/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 13 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv5/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv5/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv5/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/cnv4b/Relu" + input: "depth_net/cnv5/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/cnv5/Conv2D_grad/ShapeN" + input: "depth_net/cnv5/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/cnv5/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/cnv4b/Relu" + input: "train_op/gradients/depth_prediction/depth_net/cnv5/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/cnv5/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv5/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv5/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv5/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/cnv5/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv5/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv5/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv5/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv5/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv5/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_182" + op: "AddN" + input: "train_op/gradients/depth_prediction/depth_net/concat_2_grad/tuple/control_dependency_1" + input: "train_op/gradients/depth_prediction/depth_net/cnv5/Conv2D_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_2_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4b/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/AddN_182" + input: "depth_prediction/depth_net/cnv4b/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4b/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv4b/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4b/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv4b/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv4b/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4b/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv4b/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv4b/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv4b/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4b/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv4b/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv4b/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv4b/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4b/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/cnv4/Relu" + input: "depth_net/cnv4b/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4b/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/cnv4b/Conv2D_grad/ShapeN" + input: "depth_net/cnv4b/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/cnv4b/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4b/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/cnv4/Relu" + input: "train_op/gradients/depth_prediction/depth_net/cnv4b/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/cnv4b/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4b/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv4b/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv4b/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4b/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv4b/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/cnv4b/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv4b/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4b/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv4b/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv4b/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv4b/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv4b/Conv2D_grad/tuple/control_dependency" + input: "depth_prediction/depth_net/cnv4/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv4/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv4/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv4/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv4/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv4/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv4/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 8 + } + dim { + size: 26 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv4/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv4/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv4/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/cnv3b/Relu" + input: "depth_net/cnv4/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/cnv4/Conv2D_grad/ShapeN" + input: "depth_net/cnv4/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/cnv4/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/cnv3b/Relu" + input: "train_op/gradients/depth_prediction/depth_net/cnv4/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/cnv4/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv4/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv4/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv4/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/cnv4/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv4/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv4/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv4/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv4/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv4/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_183" + op: "AddN" + input: "train_op/gradients/depth_prediction/depth_net/concat_3_grad/tuple/control_dependency_1" + input: "train_op/gradients/depth_prediction/depth_net/cnv4/Conv2D_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_3_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3b/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/AddN_183" + input: "depth_prediction/depth_net/cnv3b/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3b/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv3b/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3b/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv3b/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv3b/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3b/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv3b/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv3b/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv3b/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3b/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv3b/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv3b/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv3b/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3b/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/cnv3/Relu" + input: "depth_net/cnv3b/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3b/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/cnv3b/Conv2D_grad/ShapeN" + input: "depth_net/cnv3b/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/cnv3b/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3b/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/cnv3/Relu" + input: "train_op/gradients/depth_prediction/depth_net/cnv3b/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/cnv3b/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3b/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv3b/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv3b/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3b/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv3b/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/cnv3b/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv3b/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3b/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv3b/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv3b/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv3b/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv3b/Conv2D_grad/tuple/control_dependency" + input: "depth_prediction/depth_net/cnv3/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv3/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv3/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv3/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv3/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv3/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv3/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv3/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv3/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv3/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/cnv2b/Relu" + input: "depth_net/cnv3/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/cnv3/Conv2D_grad/ShapeN" + input: "depth_net/cnv3/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/cnv3/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/cnv2b/Relu" + input: "train_op/gradients/depth_prediction/depth_net/cnv3/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/cnv3/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv3/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv3/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv3/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/cnv3/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv3/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv3/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv3/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv3/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv3/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_184" + op: "AddN" + input: "train_op/gradients/depth_prediction/depth_net/concat_4_grad/tuple/control_dependency_1" + input: "train_op/gradients/depth_prediction/depth_net/cnv3/Conv2D_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_4_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2b/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/AddN_184" + input: "depth_prediction/depth_net/cnv2b/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2b/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv2b/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2b/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv2b/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv2b/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2b/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv2b/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv2b/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv2b/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2b/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv2b/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv2b/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv2b/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2b/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/cnv2/Relu" + input: "depth_net/cnv2b/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2b/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/cnv2b/Conv2D_grad/ShapeN" + input: "depth_net/cnv2b/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/cnv2b/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2b/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/cnv2/Relu" + input: "train_op/gradients/depth_prediction/depth_net/cnv2b/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/cnv2b/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2b/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv2b/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv2b/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2b/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv2b/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/cnv2b/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv2b/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2b/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv2b/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv2b/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv2b/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv2b/Conv2D_grad/tuple/control_dependency" + input: "depth_prediction/depth_net/cnv2/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv2/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv2/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv2/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv2/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv2/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv2/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv2/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv2/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv2/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/cnv1b/Relu" + input: "depth_net/cnv2/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/cnv2/Conv2D_grad/ShapeN" + input: "depth_net/cnv2/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/cnv2/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/cnv1b/Relu" + input: "train_op/gradients/depth_prediction/depth_net/cnv2/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/cnv2/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv2/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv2/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv2/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/cnv2/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv2/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv2/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv2/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv2/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv2/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "train_op/gradients/AddN_185" + op: "AddN" + input: "train_op/gradients/depth_prediction/depth_net/concat_5_grad/tuple/control_dependency_1" + input: "train_op/gradients/depth_prediction/depth_net/cnv2/Conv2D_grad/tuple/control_dependency" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/concat_5_grad/Slice_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1b/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/AddN_185" + input: "depth_prediction/depth_net/cnv1b/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1b/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv1b/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1b/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv1b/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv1b/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1b/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv1b/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv1b/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv1b/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1b/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv1b/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv1b/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv1b/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1b/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "depth_prediction/depth_net/cnv1/Relu" + input: "depth_net/cnv1b/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1b/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/cnv1b/Conv2D_grad/ShapeN" + input: "depth_net/cnv1b/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/cnv1b/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1b/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "depth_prediction/depth_net/cnv1/Relu" + input: "train_op/gradients/depth_prediction/depth_net/cnv1b/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/cnv1b/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1b/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv1b/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv1b/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1b/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv1b/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/cnv1b/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv1b/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1b/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv1b/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv1b/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv1b/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1/Relu_grad/ReluGrad" + op: "ReluGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv1b/Conv2D_grad/tuple/control_dependency" + input: "depth_prediction/depth_net/cnv1/Relu" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1/BiasAdd_grad/BiasAddGrad" + op: "BiasAddGrad" + input: "train_op/gradients/depth_prediction/depth_net/cnv1/Relu_grad/ReluGrad" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1/BiasAdd_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv1/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv1/Relu_grad/ReluGrad" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1/BiasAdd_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv1/Relu_grad/ReluGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv1/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv1/Relu_grad/ReluGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1/BiasAdd_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv1/BiasAdd_grad/BiasAddGrad" + input: "^train_op/gradients/depth_prediction/depth_net/cnv1/BiasAdd_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv1/BiasAdd_grad/BiasAddGrad" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1/Conv2D_grad/ShapeN" + op: "ShapeN" + input: "data_loading/sub_4" + input: "depth_net/cnv1/weights/read" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1/Conv2D_grad/Conv2DBackpropInput" + op: "Conv2DBackpropInput" + input: "train_op/gradients/depth_prediction/depth_net/cnv1/Conv2D_grad/ShapeN" + input: "depth_net/cnv1/weights/read" + input: "train_op/gradients/depth_prediction/depth_net/cnv1/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1/Conv2D_grad/Conv2DBackpropFilter" + op: "Conv2DBackpropFilter" + input: "data_loading/sub_4" + input: "train_op/gradients/depth_prediction/depth_net/cnv1/Conv2D_grad/ShapeN:1" + input: "train_op/gradients/depth_prediction/depth_net/cnv1/BiasAdd_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1/Conv2D_grad/tuple/group_deps" + op: "NoOp" + input: "^train_op/gradients/depth_prediction/depth_net/cnv1/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv1/Conv2D_grad/Conv2DBackpropInput" +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1/Conv2D_grad/tuple/control_dependency" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv1/Conv2D_grad/Conv2DBackpropInput" + input: "^train_op/gradients/depth_prediction/depth_net/cnv1/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv1/Conv2D_grad/Conv2DBackpropInput" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "train_op/gradients/depth_prediction/depth_net/cnv1/Conv2D_grad/tuple/control_dependency_1" + op: "Identity" + input: "train_op/gradients/depth_prediction/depth_net/cnv1/Conv2D_grad/Conv2DBackpropFilter" + input: "^train_op/gradients/depth_prediction/depth_net/cnv1/Conv2D_grad/tuple/group_deps" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/gradients/depth_prediction/depth_net/cnv1/Conv2D_grad/Conv2DBackpropFilter" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "train_op/beta1_power/initial_value" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.8999999761581421 + } + } + } +} +node { + name: "train_op/beta1_power" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + 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: "train_op/beta1_power/Assign" + op: "Assign" + input: "train_op/beta1_power" + input: "train_op/beta1_power/initial_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "train_op/beta1_power/read" + op: "Identity" + input: "train_op/beta1_power" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/beta2_power/initial_value" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.9990000128746033 + } + } + } +} +node { + name: "train_op/beta2_power" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + 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: "train_op/beta2_power/Assign" + op: "Assign" + input: "train_op/beta2_power" + input: "train_op/beta2_power/initial_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "train_op/beta2_power/read" + op: "Identity" + input: "train_op/beta2_power" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "depth_net/cnv1/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\007\000\000\000\007\000\000\000\003\000\000\000 \000\000\000" + } + } + } +} +node { + name: "depth_net/cnv1/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + 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: "depth_net/cnv1/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv1/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv1/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv1/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv1/weights/Adam/Assign" + op: "Assign" + input: "depth_net/cnv1/weights/Adam" + input: "depth_net/cnv1/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv1/weights/Adam/read" + op: "Identity" + input: "depth_net/cnv1/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/cnv1/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\007\000\000\000\007\000\000\000\003\000\000\000 \000\000\000" + } + } + } +} +node { + name: "depth_net/cnv1/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + 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: "depth_net/cnv1/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv1/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv1/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv1/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv1/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv1/weights/Adam_1" + input: "depth_net/cnv1/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv1/weights/Adam_1/read" + op: "Identity" + input: "depth_net/cnv1/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/cnv1/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 32 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv1/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv1/biases/Adam/Assign" + op: "Assign" + input: "depth_net/cnv1/biases/Adam" + input: "depth_net/cnv1/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv1/biases/Adam/read" + op: "Identity" + input: "depth_net/cnv1/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/cnv1/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 32 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv1/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv1/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv1/biases/Adam_1" + input: "depth_net/cnv1/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv1/biases/Adam_1/read" + op: "Identity" + input: "depth_net/cnv1/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/cnv1b/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\007\000\000\000\007\000\000\000 \000\000\000 \000\000\000" + } + } + } +} +node { + name: "depth_net/cnv1b/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + 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: "depth_net/cnv1b/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv1b/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv1b/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv1b/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv1b/weights/Adam/Assign" + op: "Assign" + input: "depth_net/cnv1b/weights/Adam" + input: "depth_net/cnv1b/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv1b/weights/Adam/read" + op: "Identity" + input: "depth_net/cnv1b/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/cnv1b/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\007\000\000\000\007\000\000\000 \000\000\000 \000\000\000" + } + } + } +} +node { + name: "depth_net/cnv1b/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + 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: "depth_net/cnv1b/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv1b/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv1b/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv1b/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv1b/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv1b/weights/Adam_1" + input: "depth_net/cnv1b/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv1b/weights/Adam_1/read" + op: "Identity" + input: "depth_net/cnv1b/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/cnv1b/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 32 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv1b/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv1b/biases/Adam/Assign" + op: "Assign" + input: "depth_net/cnv1b/biases/Adam" + input: "depth_net/cnv1b/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv1b/biases/Adam/read" + op: "Identity" + input: "depth_net/cnv1b/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/cnv1b/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 32 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv1b/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv1b/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv1b/biases/Adam_1" + input: "depth_net/cnv1b/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv1b/biases/Adam_1/read" + op: "Identity" + input: "depth_net/cnv1b/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/cnv2/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\005\000\000\000\005\000\000\000 \000\000\000@\000\000\000" + } + } + } +} +node { + name: "depth_net/cnv2/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + 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: "depth_net/cnv2/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv2/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv2/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv2/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv2/weights/Adam/Assign" + op: "Assign" + input: "depth_net/cnv2/weights/Adam" + input: "depth_net/cnv2/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv2/weights/Adam/read" + op: "Identity" + input: "depth_net/cnv2/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/cnv2/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\005\000\000\000\005\000\000\000 \000\000\000@\000\000\000" + } + } + } +} +node { + name: "depth_net/cnv2/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + 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: "depth_net/cnv2/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv2/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv2/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv2/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv2/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv2/weights/Adam_1" + input: "depth_net/cnv2/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv2/weights/Adam_1/read" + op: "Identity" + input: "depth_net/cnv2/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/cnv2/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 64 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv2/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv2/biases/Adam/Assign" + op: "Assign" + input: "depth_net/cnv2/biases/Adam" + input: "depth_net/cnv2/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv2/biases/Adam/read" + op: "Identity" + input: "depth_net/cnv2/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/cnv2/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 64 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv2/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv2/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv2/biases/Adam_1" + input: "depth_net/cnv2/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv2/biases/Adam_1/read" + op: "Identity" + input: "depth_net/cnv2/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/cnv2b/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\005\000\000\000\005\000\000\000@\000\000\000@\000\000\000" + } + } + } +} +node { + name: "depth_net/cnv2b/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + 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: "depth_net/cnv2b/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv2b/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv2b/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv2b/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv2b/weights/Adam/Assign" + op: "Assign" + input: "depth_net/cnv2b/weights/Adam" + input: "depth_net/cnv2b/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv2b/weights/Adam/read" + op: "Identity" + input: "depth_net/cnv2b/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/cnv2b/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\005\000\000\000\005\000\000\000@\000\000\000@\000\000\000" + } + } + } +} +node { + name: "depth_net/cnv2b/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + 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: "depth_net/cnv2b/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv2b/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv2b/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv2b/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv2b/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv2b/weights/Adam_1" + input: "depth_net/cnv2b/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv2b/weights/Adam_1/read" + op: "Identity" + input: "depth_net/cnv2b/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/cnv2b/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 64 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv2b/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv2b/biases/Adam/Assign" + op: "Assign" + input: "depth_net/cnv2b/biases/Adam" + input: "depth_net/cnv2b/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv2b/biases/Adam/read" + op: "Identity" + input: "depth_net/cnv2b/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/cnv2b/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 64 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv2b/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv2b/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv2b/biases/Adam_1" + input: "depth_net/cnv2b/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv2b/biases/Adam_1/read" + op: "Identity" + input: "depth_net/cnv2b/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/cnv3/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000@\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "depth_net/cnv3/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + 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: "depth_net/cnv3/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv3/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv3/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv3/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv3/weights/Adam/Assign" + op: "Assign" + input: "depth_net/cnv3/weights/Adam" + input: "depth_net/cnv3/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv3/weights/Adam/read" + op: "Identity" + input: "depth_net/cnv3/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/cnv3/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000@\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "depth_net/cnv3/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + 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: "depth_net/cnv3/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv3/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv3/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv3/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv3/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv3/weights/Adam_1" + input: "depth_net/cnv3/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv3/weights/Adam_1/read" + op: "Identity" + input: "depth_net/cnv3/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/cnv3/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 128 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv3/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv3/biases/Adam/Assign" + op: "Assign" + input: "depth_net/cnv3/biases/Adam" + input: "depth_net/cnv3/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv3/biases/Adam/read" + op: "Identity" + input: "depth_net/cnv3/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/cnv3/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 128 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv3/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv3/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv3/biases/Adam_1" + input: "depth_net/cnv3/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv3/biases/Adam_1/read" + op: "Identity" + input: "depth_net/cnv3/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/cnv3b/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "depth_net/cnv3b/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + 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: "depth_net/cnv3b/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv3b/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv3b/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv3b/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv3b/weights/Adam/Assign" + op: "Assign" + input: "depth_net/cnv3b/weights/Adam" + input: "depth_net/cnv3b/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv3b/weights/Adam/read" + op: "Identity" + input: "depth_net/cnv3b/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/cnv3b/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "depth_net/cnv3b/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + 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: "depth_net/cnv3b/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv3b/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv3b/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv3b/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv3b/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv3b/weights/Adam_1" + input: "depth_net/cnv3b/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv3b/weights/Adam_1/read" + op: "Identity" + input: "depth_net/cnv3b/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/cnv3b/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 128 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv3b/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv3b/biases/Adam/Assign" + op: "Assign" + input: "depth_net/cnv3b/biases/Adam" + input: "depth_net/cnv3b/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv3b/biases/Adam/read" + op: "Identity" + input: "depth_net/cnv3b/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/cnv3b/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 128 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv3b/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv3b/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv3b/biases/Adam_1" + input: "depth_net/cnv3b/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv3b/biases/Adam_1/read" + op: "Identity" + input: "depth_net/cnv3b/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/cnv4/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\000\001\000\000" + } + } + } +} +node { + name: "depth_net/cnv4/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + 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: "depth_net/cnv4/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv4/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv4/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv4/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv4/weights/Adam/Assign" + op: "Assign" + input: "depth_net/cnv4/weights/Adam" + input: "depth_net/cnv4/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv4/weights/Adam/read" + op: "Identity" + input: "depth_net/cnv4/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/cnv4/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\000\001\000\000" + } + } + } +} +node { + name: "depth_net/cnv4/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + 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: "depth_net/cnv4/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv4/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv4/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv4/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv4/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv4/weights/Adam_1" + input: "depth_net/cnv4/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv4/weights/Adam_1/read" + op: "Identity" + input: "depth_net/cnv4/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/cnv4/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv4/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv4/biases/Adam/Assign" + op: "Assign" + input: "depth_net/cnv4/biases/Adam" + input: "depth_net/cnv4/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv4/biases/Adam/read" + op: "Identity" + input: "depth_net/cnv4/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/cnv4/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv4/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv4/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv4/biases/Adam_1" + input: "depth_net/cnv4/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv4/biases/Adam_1/read" + op: "Identity" + input: "depth_net/cnv4/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/cnv4b/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\001\000\000" + } + } + } +} +node { + name: "depth_net/cnv4b/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + 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: "depth_net/cnv4b/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv4b/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv4b/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv4b/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv4b/weights/Adam/Assign" + op: "Assign" + input: "depth_net/cnv4b/weights/Adam" + input: "depth_net/cnv4b/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv4b/weights/Adam/read" + op: "Identity" + input: "depth_net/cnv4b/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/cnv4b/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\001\000\000" + } + } + } +} +node { + name: "depth_net/cnv4b/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + 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: "depth_net/cnv4b/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv4b/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv4b/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv4b/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv4b/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv4b/weights/Adam_1" + input: "depth_net/cnv4b/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv4b/weights/Adam_1/read" + op: "Identity" + input: "depth_net/cnv4b/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/cnv4b/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv4b/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv4b/biases/Adam/Assign" + op: "Assign" + input: "depth_net/cnv4b/biases/Adam" + input: "depth_net/cnv4b/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv4b/biases/Adam/read" + op: "Identity" + input: "depth_net/cnv4b/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/cnv4b/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv4b/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv4b/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv4b/biases/Adam_1" + input: "depth_net/cnv4b/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv4b/biases/Adam_1/read" + op: "Identity" + input: "depth_net/cnv4b/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/cnv5/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/cnv5/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + 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: "depth_net/cnv5/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv5/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv5/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv5/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv5/weights/Adam/Assign" + op: "Assign" + input: "depth_net/cnv5/weights/Adam" + input: "depth_net/cnv5/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv5/weights/Adam/read" + op: "Identity" + input: "depth_net/cnv5/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv5/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/cnv5/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + 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: "depth_net/cnv5/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv5/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv5/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv5/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv5/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv5/weights/Adam_1" + input: "depth_net/cnv5/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv5/weights/Adam_1/read" + op: "Identity" + input: "depth_net/cnv5/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv5/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv5/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv5/biases/Adam/Assign" + op: "Assign" + input: "depth_net/cnv5/biases/Adam" + input: "depth_net/cnv5/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv5/biases/Adam/read" + op: "Identity" + input: "depth_net/cnv5/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv5/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv5/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv5/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv5/biases/Adam_1" + input: "depth_net/cnv5/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv5/biases/Adam_1/read" + op: "Identity" + input: "depth_net/cnv5/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv5b/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/cnv5b/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + 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: "depth_net/cnv5b/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv5b/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv5b/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv5b/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv5b/weights/Adam/Assign" + op: "Assign" + input: "depth_net/cnv5b/weights/Adam" + input: "depth_net/cnv5b/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv5b/weights/Adam/read" + op: "Identity" + input: "depth_net/cnv5b/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv5b/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/cnv5b/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + 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: "depth_net/cnv5b/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv5b/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv5b/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv5b/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv5b/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv5b/weights/Adam_1" + input: "depth_net/cnv5b/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv5b/weights/Adam_1/read" + op: "Identity" + input: "depth_net/cnv5b/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv5b/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv5b/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv5b/biases/Adam/Assign" + op: "Assign" + input: "depth_net/cnv5b/biases/Adam" + input: "depth_net/cnv5b/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv5b/biases/Adam/read" + op: "Identity" + input: "depth_net/cnv5b/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv5b/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv5b/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv5b/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv5b/biases/Adam_1" + input: "depth_net/cnv5b/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv5b/biases/Adam_1/read" + op: "Identity" + input: "depth_net/cnv5b/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv6/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/cnv6/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + 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: "depth_net/cnv6/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv6/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv6/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv6/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv6/weights/Adam/Assign" + op: "Assign" + input: "depth_net/cnv6/weights/Adam" + input: "depth_net/cnv6/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv6/weights/Adam/read" + op: "Identity" + input: "depth_net/cnv6/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv6/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/cnv6/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + 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: "depth_net/cnv6/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv6/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv6/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv6/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv6/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv6/weights/Adam_1" + input: "depth_net/cnv6/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv6/weights/Adam_1/read" + op: "Identity" + input: "depth_net/cnv6/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv6/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv6/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv6/biases/Adam/Assign" + op: "Assign" + input: "depth_net/cnv6/biases/Adam" + input: "depth_net/cnv6/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv6/biases/Adam/read" + op: "Identity" + input: "depth_net/cnv6/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv6/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv6/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv6/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv6/biases/Adam_1" + input: "depth_net/cnv6/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv6/biases/Adam_1/read" + op: "Identity" + input: "depth_net/cnv6/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv6b/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/cnv6b/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + 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: "depth_net/cnv6b/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv6b/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv6b/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv6b/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv6b/weights/Adam/Assign" + op: "Assign" + input: "depth_net/cnv6b/weights/Adam" + input: "depth_net/cnv6b/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv6b/weights/Adam/read" + op: "Identity" + input: "depth_net/cnv6b/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv6b/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/cnv6b/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + 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: "depth_net/cnv6b/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv6b/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv6b/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv6b/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv6b/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv6b/weights/Adam_1" + input: "depth_net/cnv6b/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv6b/weights/Adam_1/read" + op: "Identity" + input: "depth_net/cnv6b/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv6b/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv6b/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv6b/biases/Adam/Assign" + op: "Assign" + input: "depth_net/cnv6b/biases/Adam" + input: "depth_net/cnv6b/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv6b/biases/Adam/read" + op: "Identity" + input: "depth_net/cnv6b/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv6b/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv6b/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv6b/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv6b/biases/Adam_1" + input: "depth_net/cnv6b/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv6b/biases/Adam_1/read" + op: "Identity" + input: "depth_net/cnv6b/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv7/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/cnv7/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + 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: "depth_net/cnv7/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv7/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv7/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv7/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv7/weights/Adam/Assign" + op: "Assign" + input: "depth_net/cnv7/weights/Adam" + input: "depth_net/cnv7/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv7/weights/Adam/read" + op: "Identity" + input: "depth_net/cnv7/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv7/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/cnv7/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + 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: "depth_net/cnv7/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv7/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv7/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv7/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv7/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv7/weights/Adam_1" + input: "depth_net/cnv7/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv7/weights/Adam_1/read" + op: "Identity" + input: "depth_net/cnv7/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv7/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv7/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv7/biases/Adam/Assign" + op: "Assign" + input: "depth_net/cnv7/biases/Adam" + input: "depth_net/cnv7/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv7/biases/Adam/read" + op: "Identity" + input: "depth_net/cnv7/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv7/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv7/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv7/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv7/biases/Adam_1" + input: "depth_net/cnv7/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv7/biases/Adam_1/read" + op: "Identity" + input: "depth_net/cnv7/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv7b/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/cnv7b/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + 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: "depth_net/cnv7b/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv7b/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv7b/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv7b/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv7b/weights/Adam/Assign" + op: "Assign" + input: "depth_net/cnv7b/weights/Adam" + input: "depth_net/cnv7b/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv7b/weights/Adam/read" + op: "Identity" + input: "depth_net/cnv7b/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv7b/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/cnv7b/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + 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: "depth_net/cnv7b/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/cnv7b/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/cnv7b/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/cnv7b/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv7b/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv7b/weights/Adam_1" + input: "depth_net/cnv7b/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv7b/weights/Adam_1/read" + op: "Identity" + input: "depth_net/cnv7b/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv7b/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv7b/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv7b/biases/Adam/Assign" + op: "Assign" + input: "depth_net/cnv7b/biases/Adam" + input: "depth_net/cnv7b/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv7b/biases/Adam/read" + op: "Identity" + input: "depth_net/cnv7b/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/cnv7b/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/cnv7b/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/cnv7b/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/cnv7b/biases/Adam_1" + input: "depth_net/cnv7b/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/cnv7b/biases/Adam_1/read" + op: "Identity" + input: "depth_net/cnv7b/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv7/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/upcnv7/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + 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: "depth_net/upcnv7/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/upcnv7/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/upcnv7/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/upcnv7/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv7/weights/Adam/Assign" + op: "Assign" + input: "depth_net/upcnv7/weights/Adam" + input: "depth_net/upcnv7/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv7/weights/Adam/read" + op: "Identity" + input: "depth_net/upcnv7/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv7/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/upcnv7/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + 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: "depth_net/upcnv7/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/upcnv7/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/upcnv7/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/upcnv7/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv7/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/upcnv7/weights/Adam_1" + input: "depth_net/upcnv7/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv7/weights/Adam_1/read" + op: "Identity" + input: "depth_net/upcnv7/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv7/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv7/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv7/biases/Adam/Assign" + op: "Assign" + input: "depth_net/upcnv7/biases/Adam" + input: "depth_net/upcnv7/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv7/biases/Adam/read" + op: "Identity" + input: "depth_net/upcnv7/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv7/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv7/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv7/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/upcnv7/biases/Adam_1" + input: "depth_net/upcnv7/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv7/biases/Adam_1/read" + op: "Identity" + input: "depth_net/upcnv7/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/icnv7/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\004\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/icnv7/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + 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: "depth_net/icnv7/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/icnv7/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/icnv7/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/icnv7/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv7/weights/Adam/Assign" + op: "Assign" + input: "depth_net/icnv7/weights/Adam" + input: "depth_net/icnv7/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv7/weights/Adam/read" + op: "Identity" + input: "depth_net/icnv7/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/icnv7/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\004\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/icnv7/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + 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: "depth_net/icnv7/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/icnv7/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/icnv7/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/icnv7/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv7/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/icnv7/weights/Adam_1" + input: "depth_net/icnv7/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv7/weights/Adam_1/read" + op: "Identity" + input: "depth_net/icnv7/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/icnv7/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv7/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv7/biases/Adam/Assign" + op: "Assign" + input: "depth_net/icnv7/biases/Adam" + input: "depth_net/icnv7/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv7/biases/Adam/read" + op: "Identity" + input: "depth_net/icnv7/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/icnv7/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv7/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv7/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/icnv7/biases/Adam_1" + input: "depth_net/icnv7/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv7/biases/Adam_1/read" + op: "Identity" + input: "depth_net/icnv7/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv6/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/upcnv6/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + 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: "depth_net/upcnv6/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/upcnv6/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/upcnv6/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/upcnv6/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv6/weights/Adam/Assign" + op: "Assign" + input: "depth_net/upcnv6/weights/Adam" + input: "depth_net/upcnv6/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv6/weights/Adam/read" + op: "Identity" + input: "depth_net/upcnv6/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv6/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/upcnv6/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + 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: "depth_net/upcnv6/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/upcnv6/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/upcnv6/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/upcnv6/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv6/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/upcnv6/weights/Adam_1" + input: "depth_net/upcnv6/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv6/weights/Adam_1/read" + op: "Identity" + input: "depth_net/upcnv6/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv6/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv6/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv6/biases/Adam/Assign" + op: "Assign" + input: "depth_net/upcnv6/biases/Adam" + input: "depth_net/upcnv6/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv6/biases/Adam/read" + op: "Identity" + input: "depth_net/upcnv6/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv6/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv6/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv6/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/upcnv6/biases/Adam_1" + input: "depth_net/upcnv6/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv6/biases/Adam_1/read" + op: "Identity" + input: "depth_net/upcnv6/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/icnv6/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\004\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/icnv6/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + 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: "depth_net/icnv6/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/icnv6/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/icnv6/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/icnv6/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv6/weights/Adam/Assign" + op: "Assign" + input: "depth_net/icnv6/weights/Adam" + input: "depth_net/icnv6/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv6/weights/Adam/read" + op: "Identity" + input: "depth_net/icnv6/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/icnv6/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\004\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/icnv6/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + 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: "depth_net/icnv6/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/icnv6/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/icnv6/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/icnv6/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv6/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/icnv6/weights/Adam_1" + input: "depth_net/icnv6/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv6/weights/Adam_1/read" + op: "Identity" + input: "depth_net/icnv6/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/icnv6/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv6/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv6/biases/Adam/Assign" + op: "Assign" + input: "depth_net/icnv6/biases/Adam" + input: "depth_net/icnv6/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv6/biases/Adam/read" + op: "Identity" + input: "depth_net/icnv6/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/icnv6/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv6/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv6/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/icnv6/biases/Adam_1" + input: "depth_net/icnv6/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv6/biases/Adam_1/read" + op: "Identity" + input: "depth_net/icnv6/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv5/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/upcnv5/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + 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: "depth_net/upcnv5/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/upcnv5/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/upcnv5/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/upcnv5/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv5/weights/Adam/Assign" + op: "Assign" + input: "depth_net/upcnv5/weights/Adam" + input: "depth_net/upcnv5/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv5/weights/Adam/read" + op: "Identity" + input: "depth_net/upcnv5/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv5/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\002\000\000" + } + } + } +} +node { + name: "depth_net/upcnv5/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + 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: "depth_net/upcnv5/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/upcnv5/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/upcnv5/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/upcnv5/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv5/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/upcnv5/weights/Adam_1" + input: "depth_net/upcnv5/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv5/weights/Adam_1/read" + op: "Identity" + input: "depth_net/upcnv5/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "depth_net/upcnv5/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv5/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv5/biases/Adam/Assign" + op: "Assign" + input: "depth_net/upcnv5/biases/Adam" + input: "depth_net/upcnv5/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv5/biases/Adam/read" + op: "Identity" + input: "depth_net/upcnv5/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/upcnv5/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv5/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv5/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/upcnv5/biases/Adam_1" + input: "depth_net/upcnv5/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv5/biases/Adam_1/read" + op: "Identity" + input: "depth_net/upcnv5/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/icnv5/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\001\000\000" + } + } + } +} +node { + name: "depth_net/icnv5/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + 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: "depth_net/icnv5/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/icnv5/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/icnv5/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/icnv5/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv5/weights/Adam/Assign" + op: "Assign" + input: "depth_net/icnv5/weights/Adam" + input: "depth_net/icnv5/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv5/weights/Adam/read" + op: "Identity" + input: "depth_net/icnv5/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/icnv5/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\001\000\000" + } + } + } +} +node { + name: "depth_net/icnv5/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + 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: "depth_net/icnv5/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/icnv5/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/icnv5/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/icnv5/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv5/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/icnv5/weights/Adam_1" + input: "depth_net/icnv5/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv5/weights/Adam_1/read" + op: "Identity" + input: "depth_net/icnv5/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/icnv5/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv5/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv5/biases/Adam/Assign" + op: "Assign" + input: "depth_net/icnv5/biases/Adam" + input: "depth_net/icnv5/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv5/biases/Adam/read" + op: "Identity" + input: "depth_net/icnv5/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/icnv5/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv5/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv5/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/icnv5/biases/Adam_1" + input: "depth_net/icnv5/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv5/biases/Adam_1/read" + op: "Identity" + input: "depth_net/icnv5/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/upcnv4/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\000\001\000\000" + } + } + } +} +node { + name: "depth_net/upcnv4/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + 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: "depth_net/upcnv4/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/upcnv4/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/upcnv4/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/upcnv4/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv4/weights/Adam/Assign" + op: "Assign" + input: "depth_net/upcnv4/weights/Adam" + input: "depth_net/upcnv4/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv4/weights/Adam/read" + op: "Identity" + input: "depth_net/upcnv4/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/upcnv4/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\000\001\000\000" + } + } + } +} +node { + name: "depth_net/upcnv4/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + 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: "depth_net/upcnv4/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/upcnv4/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/upcnv4/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/upcnv4/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv4/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/upcnv4/weights/Adam_1" + input: "depth_net/upcnv4/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv4/weights/Adam_1/read" + op: "Identity" + input: "depth_net/upcnv4/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "depth_net/upcnv4/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 128 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv4/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv4/biases/Adam/Assign" + op: "Assign" + input: "depth_net/upcnv4/biases/Adam" + input: "depth_net/upcnv4/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv4/biases/Adam/read" + op: "Identity" + input: "depth_net/upcnv4/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/upcnv4/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 128 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv4/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv4/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/upcnv4/biases/Adam_1" + input: "depth_net/upcnv4/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv4/biases/Adam_1/read" + op: "Identity" + input: "depth_net/upcnv4/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/icnv4/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\200\000\000\000" + } + } + } +} +node { + name: "depth_net/icnv4/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + 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: "depth_net/icnv4/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/icnv4/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/icnv4/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/icnv4/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv4/weights/Adam/Assign" + op: "Assign" + input: "depth_net/icnv4/weights/Adam" + input: "depth_net/icnv4/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv4/weights/Adam/read" + op: "Identity" + input: "depth_net/icnv4/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/icnv4/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\200\000\000\000" + } + } + } +} +node { + name: "depth_net/icnv4/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + 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: "depth_net/icnv4/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/icnv4/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/icnv4/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/icnv4/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv4/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/icnv4/weights/Adam_1" + input: "depth_net/icnv4/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv4/weights/Adam_1/read" + op: "Identity" + input: "depth_net/icnv4/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/icnv4/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 128 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv4/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv4/biases/Adam/Assign" + op: "Assign" + input: "depth_net/icnv4/biases/Adam" + input: "depth_net/icnv4/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv4/biases/Adam/read" + op: "Identity" + input: "depth_net/icnv4/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/icnv4/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 128 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv4/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv4/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/icnv4/biases/Adam_1" + input: "depth_net/icnv4/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv4/biases/Adam_1/read" + op: "Identity" + input: "depth_net/icnv4/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/disp4/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_net/disp4/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + 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: "depth_net/disp4/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/disp4/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/disp4/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/disp4/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp4/weights/Adam/Assign" + op: "Assign" + input: "depth_net/disp4/weights/Adam" + input: "depth_net/disp4/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp4/weights/Adam/read" + op: "Identity" + input: "depth_net/disp4/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp4/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "depth_net/disp4/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + 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: "depth_net/disp4/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/disp4/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/disp4/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/disp4/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp4/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/disp4/weights/Adam_1" + input: "depth_net/disp4/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp4/weights/Adam_1/read" + op: "Identity" + input: "depth_net/disp4/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp4/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/disp4/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp4/biases/Adam/Assign" + op: "Assign" + input: "depth_net/disp4/biases/Adam" + input: "depth_net/disp4/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp4/biases/Adam/read" + op: "Identity" + input: "depth_net/disp4/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp4/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/disp4/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp4/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/disp4/biases/Adam_1" + input: "depth_net/disp4/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp4/biases/Adam_1/read" + op: "Identity" + input: "depth_net/disp4/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/upcnv3/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000@\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "depth_net/upcnv3/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + 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: "depth_net/upcnv3/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/upcnv3/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/upcnv3/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/upcnv3/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv3/weights/Adam/Assign" + op: "Assign" + input: "depth_net/upcnv3/weights/Adam" + input: "depth_net/upcnv3/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv3/weights/Adam/read" + op: "Identity" + input: "depth_net/upcnv3/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/upcnv3/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000@\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "depth_net/upcnv3/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + 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: "depth_net/upcnv3/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/upcnv3/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/upcnv3/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/upcnv3/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv3/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/upcnv3/weights/Adam_1" + input: "depth_net/upcnv3/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv3/weights/Adam_1/read" + op: "Identity" + input: "depth_net/upcnv3/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "depth_net/upcnv3/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 64 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv3/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv3/biases/Adam/Assign" + op: "Assign" + input: "depth_net/upcnv3/biases/Adam" + input: "depth_net/upcnv3/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv3/biases/Adam/read" + op: "Identity" + input: "depth_net/upcnv3/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/upcnv3/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 64 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv3/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv3/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/upcnv3/biases/Adam_1" + input: "depth_net/upcnv3/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv3/biases/Adam_1/read" + op: "Identity" + input: "depth_net/upcnv3/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/icnv3/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\201\000\000\000@\000\000\000" + } + } + } +} +node { + name: "depth_net/icnv3/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + 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: "depth_net/icnv3/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/icnv3/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/icnv3/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/icnv3/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv3/weights/Adam/Assign" + op: "Assign" + input: "depth_net/icnv3/weights/Adam" + input: "depth_net/icnv3/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv3/weights/Adam/read" + op: "Identity" + input: "depth_net/icnv3/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/icnv3/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\201\000\000\000@\000\000\000" + } + } + } +} +node { + name: "depth_net/icnv3/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + 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: "depth_net/icnv3/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/icnv3/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/icnv3/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/icnv3/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv3/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/icnv3/weights/Adam_1" + input: "depth_net/icnv3/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv3/weights/Adam_1/read" + op: "Identity" + input: "depth_net/icnv3/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/icnv3/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 64 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv3/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv3/biases/Adam/Assign" + op: "Assign" + input: "depth_net/icnv3/biases/Adam" + input: "depth_net/icnv3/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv3/biases/Adam/read" + op: "Identity" + input: "depth_net/icnv3/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/icnv3/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 64 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv3/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv3/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/icnv3/biases/Adam_1" + input: "depth_net/icnv3/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv3/biases/Adam_1/read" + op: "Identity" + input: "depth_net/icnv3/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/disp3/weights/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/disp3/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp3/weights/Adam/Assign" + op: "Assign" + input: "depth_net/disp3/weights/Adam" + input: "depth_net/disp3/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp3/weights/Adam/read" + op: "Identity" + input: "depth_net/disp3/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp3/weights/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/disp3/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp3/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/disp3/weights/Adam_1" + input: "depth_net/disp3/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp3/weights/Adam_1/read" + op: "Identity" + input: "depth_net/disp3/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp3/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/disp3/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp3/biases/Adam/Assign" + op: "Assign" + input: "depth_net/disp3/biases/Adam" + input: "depth_net/disp3/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp3/biases/Adam/read" + op: "Identity" + input: "depth_net/disp3/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp3/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/disp3/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp3/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/disp3/biases/Adam_1" + input: "depth_net/disp3/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp3/biases/Adam_1/read" + op: "Identity" + input: "depth_net/disp3/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/upcnv2/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000 \000\000\000@\000\000\000" + } + } + } +} +node { + name: "depth_net/upcnv2/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + 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: "depth_net/upcnv2/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/upcnv2/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/upcnv2/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/upcnv2/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv2/weights/Adam/Assign" + op: "Assign" + input: "depth_net/upcnv2/weights/Adam" + input: "depth_net/upcnv2/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv2/weights/Adam/read" + op: "Identity" + input: "depth_net/upcnv2/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/upcnv2/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000 \000\000\000@\000\000\000" + } + } + } +} +node { + name: "depth_net/upcnv2/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + 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: "depth_net/upcnv2/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/upcnv2/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/upcnv2/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/upcnv2/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv2/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/upcnv2/weights/Adam_1" + input: "depth_net/upcnv2/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv2/weights/Adam_1/read" + op: "Identity" + input: "depth_net/upcnv2/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "depth_net/upcnv2/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 32 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv2/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv2/biases/Adam/Assign" + op: "Assign" + input: "depth_net/upcnv2/biases/Adam" + input: "depth_net/upcnv2/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv2/biases/Adam/read" + op: "Identity" + input: "depth_net/upcnv2/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/upcnv2/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 32 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv2/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv2/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/upcnv2/biases/Adam_1" + input: "depth_net/upcnv2/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv2/biases/Adam_1/read" + op: "Identity" + input: "depth_net/upcnv2/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/icnv2/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000A\000\000\000 \000\000\000" + } + } + } +} +node { + name: "depth_net/icnv2/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + 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: "depth_net/icnv2/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/icnv2/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/icnv2/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/icnv2/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv2/weights/Adam/Assign" + op: "Assign" + input: "depth_net/icnv2/weights/Adam" + input: "depth_net/icnv2/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv2/weights/Adam/read" + op: "Identity" + input: "depth_net/icnv2/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/icnv2/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000A\000\000\000 \000\000\000" + } + } + } +} +node { + name: "depth_net/icnv2/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + 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: "depth_net/icnv2/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/icnv2/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/icnv2/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/icnv2/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv2/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/icnv2/weights/Adam_1" + input: "depth_net/icnv2/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv2/weights/Adam_1/read" + op: "Identity" + input: "depth_net/icnv2/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/icnv2/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 32 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv2/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv2/biases/Adam/Assign" + op: "Assign" + input: "depth_net/icnv2/biases/Adam" + input: "depth_net/icnv2/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv2/biases/Adam/read" + op: "Identity" + input: "depth_net/icnv2/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/icnv2/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 32 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv2/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv2/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/icnv2/biases/Adam_1" + input: "depth_net/icnv2/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv2/biases/Adam_1/read" + op: "Identity" + input: "depth_net/icnv2/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/disp2/weights/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/disp2/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp2/weights/Adam/Assign" + op: "Assign" + input: "depth_net/disp2/weights/Adam" + input: "depth_net/disp2/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp2/weights/Adam/read" + op: "Identity" + input: "depth_net/disp2/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp2/weights/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/disp2/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp2/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/disp2/weights/Adam_1" + input: "depth_net/disp2/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp2/weights/Adam_1/read" + op: "Identity" + input: "depth_net/disp2/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp2/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/disp2/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp2/biases/Adam/Assign" + op: "Assign" + input: "depth_net/disp2/biases/Adam" + input: "depth_net/disp2/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp2/biases/Adam/read" + op: "Identity" + input: "depth_net/disp2/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp2/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/disp2/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp2/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/disp2/biases/Adam_1" + input: "depth_net/disp2/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp2/biases/Adam_1/read" + op: "Identity" + input: "depth_net/disp2/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/upcnv1/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\020\000\000\000 \000\000\000" + } + } + } +} +node { + name: "depth_net/upcnv1/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + 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: "depth_net/upcnv1/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/upcnv1/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/upcnv1/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/upcnv1/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv1/weights/Adam/Assign" + op: "Assign" + input: "depth_net/upcnv1/weights/Adam" + input: "depth_net/upcnv1/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv1/weights/Adam/read" + op: "Identity" + input: "depth_net/upcnv1/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/upcnv1/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\020\000\000\000 \000\000\000" + } + } + } +} +node { + name: "depth_net/upcnv1/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + 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: "depth_net/upcnv1/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/upcnv1/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/upcnv1/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/upcnv1/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv1/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/upcnv1/weights/Adam_1" + input: "depth_net/upcnv1/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv1/weights/Adam_1/read" + op: "Identity" + input: "depth_net/upcnv1/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "depth_net/upcnv1/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 16 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv1/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 16 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv1/biases/Adam/Assign" + op: "Assign" + input: "depth_net/upcnv1/biases/Adam" + input: "depth_net/upcnv1/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv1/biases/Adam/read" + op: "Identity" + input: "depth_net/upcnv1/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } +} +node { + name: "depth_net/upcnv1/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 16 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/upcnv1/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 16 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/upcnv1/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/upcnv1/biases/Adam_1" + input: "depth_net/upcnv1/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/upcnv1/biases/Adam_1/read" + op: "Identity" + input: "depth_net/upcnv1/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } +} +node { + name: "depth_net/icnv1/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\021\000\000\000\020\000\000\000" + } + } + } +} +node { + name: "depth_net/icnv1/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + 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: "depth_net/icnv1/weights/Adam/Initializer/zeros" + op: "Fill" + input: "depth_net/icnv1/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "depth_net/icnv1/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/icnv1/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv1/weights/Adam/Assign" + op: "Assign" + input: "depth_net/icnv1/weights/Adam" + input: "depth_net/icnv1/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv1/weights/Adam/read" + op: "Identity" + input: "depth_net/icnv1/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "depth_net/icnv1/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\021\000\000\000\020\000\000\000" + } + } + } +} +node { + name: "depth_net/icnv1/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + 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: "depth_net/icnv1/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "depth_net/icnv1/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "depth_net/icnv1/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "depth_net/icnv1/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv1/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/icnv1/weights/Adam_1" + input: "depth_net/icnv1/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv1/weights/Adam_1/read" + op: "Identity" + input: "depth_net/icnv1/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "depth_net/icnv1/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 16 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv1/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 16 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv1/biases/Adam/Assign" + op: "Assign" + input: "depth_net/icnv1/biases/Adam" + input: "depth_net/icnv1/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv1/biases/Adam/read" + op: "Identity" + input: "depth_net/icnv1/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } +} +node { + name: "depth_net/icnv1/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 16 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/icnv1/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 16 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/icnv1/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/icnv1/biases/Adam_1" + input: "depth_net/icnv1/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/icnv1/biases/Adam_1/read" + op: "Identity" + input: "depth_net/icnv1/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } +} +node { + name: "depth_net/disp1/weights/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/disp1/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp1/weights/Adam/Assign" + op: "Assign" + input: "depth_net/disp1/weights/Adam" + input: "depth_net/disp1/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp1/weights/Adam/read" + op: "Identity" + input: "depth_net/disp1/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp1/weights/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/disp1/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp1/weights/Adam_1/Assign" + op: "Assign" + input: "depth_net/disp1/weights/Adam_1" + input: "depth_net/disp1/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp1/weights/Adam_1/read" + op: "Identity" + input: "depth_net/disp1/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp1/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/disp1/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp1/biases/Adam/Assign" + op: "Assign" + input: "depth_net/disp1/biases/Adam" + input: "depth_net/disp1/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp1/biases/Adam/read" + op: "Identity" + input: "depth_net/disp1/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "depth_net/disp1/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "depth_net/disp1/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "depth_net/disp1/biases/Adam_1/Assign" + op: "Assign" + input: "depth_net/disp1/biases/Adam_1" + input: "depth_net/disp1/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "depth_net/disp1/biases/Adam_1/read" + op: "Identity" + input: "depth_net/disp1/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv1/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\007\000\000\000\007\000\000\000\t\000\000\000\020\000\000\000" + } + } + } +} +node { + name: "pose_exp_net/cnv1/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + 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: "pose_exp_net/cnv1/weights/Adam/Initializer/zeros" + op: "Fill" + input: "pose_exp_net/cnv1/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "pose_exp_net/cnv1/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "pose_exp_net/cnv1/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv1/weights/Adam/Assign" + op: "Assign" + input: "pose_exp_net/cnv1/weights/Adam" + input: "pose_exp_net/cnv1/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv1/weights/Adam/read" + op: "Identity" + input: "pose_exp_net/cnv1/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv1/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\007\000\000\000\007\000\000\000\t\000\000\000\020\000\000\000" + } + } + } +} +node { + name: "pose_exp_net/cnv1/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + 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: "pose_exp_net/cnv1/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "pose_exp_net/cnv1/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "pose_exp_net/cnv1/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "pose_exp_net/cnv1/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv1/weights/Adam_1/Assign" + op: "Assign" + input: "pose_exp_net/cnv1/weights/Adam_1" + input: "pose_exp_net/cnv1/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv1/weights/Adam_1/read" + op: "Identity" + input: "pose_exp_net/cnv1/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv1/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 16 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/cnv1/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 16 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv1/biases/Adam/Assign" + op: "Assign" + input: "pose_exp_net/cnv1/biases/Adam" + input: "pose_exp_net/cnv1/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv1/biases/Adam/read" + op: "Identity" + input: "pose_exp_net/cnv1/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv1/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 16 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/cnv1/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 16 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv1/biases/Adam_1/Assign" + op: "Assign" + input: "pose_exp_net/cnv1/biases/Adam_1" + input: "pose_exp_net/cnv1/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv1/biases/Adam_1/read" + op: "Identity" + input: "pose_exp_net/cnv1/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv2/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\005\000\000\000\005\000\000\000\020\000\000\000 \000\000\000" + } + } + } +} +node { + name: "pose_exp_net/cnv2/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + 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: "pose_exp_net/cnv2/weights/Adam/Initializer/zeros" + op: "Fill" + input: "pose_exp_net/cnv2/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "pose_exp_net/cnv2/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "pose_exp_net/cnv2/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv2/weights/Adam/Assign" + op: "Assign" + input: "pose_exp_net/cnv2/weights/Adam" + input: "pose_exp_net/cnv2/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv2/weights/Adam/read" + op: "Identity" + input: "pose_exp_net/cnv2/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv2/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\005\000\000\000\005\000\000\000\020\000\000\000 \000\000\000" + } + } + } +} +node { + name: "pose_exp_net/cnv2/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + 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: "pose_exp_net/cnv2/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "pose_exp_net/cnv2/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "pose_exp_net/cnv2/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "pose_exp_net/cnv2/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv2/weights/Adam_1/Assign" + op: "Assign" + input: "pose_exp_net/cnv2/weights/Adam_1" + input: "pose_exp_net/cnv2/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv2/weights/Adam_1/read" + op: "Identity" + input: "pose_exp_net/cnv2/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv2/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 32 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/cnv2/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv2/biases/Adam/Assign" + op: "Assign" + input: "pose_exp_net/cnv2/biases/Adam" + input: "pose_exp_net/cnv2/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv2/biases/Adam/read" + op: "Identity" + input: "pose_exp_net/cnv2/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv2/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 32 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/cnv2/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 32 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv2/biases/Adam_1/Assign" + op: "Assign" + input: "pose_exp_net/cnv2/biases/Adam_1" + input: "pose_exp_net/cnv2/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv2/biases/Adam_1/read" + op: "Identity" + input: "pose_exp_net/cnv2/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv3/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000 \000\000\000@\000\000\000" + } + } + } +} +node { + name: "pose_exp_net/cnv3/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + 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: "pose_exp_net/cnv3/weights/Adam/Initializer/zeros" + op: "Fill" + input: "pose_exp_net/cnv3/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "pose_exp_net/cnv3/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "pose_exp_net/cnv3/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv3/weights/Adam/Assign" + op: "Assign" + input: "pose_exp_net/cnv3/weights/Adam" + input: "pose_exp_net/cnv3/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv3/weights/Adam/read" + op: "Identity" + input: "pose_exp_net/cnv3/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv3/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000 \000\000\000@\000\000\000" + } + } + } +} +node { + name: "pose_exp_net/cnv3/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + 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: "pose_exp_net/cnv3/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "pose_exp_net/cnv3/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "pose_exp_net/cnv3/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "pose_exp_net/cnv3/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv3/weights/Adam_1/Assign" + op: "Assign" + input: "pose_exp_net/cnv3/weights/Adam_1" + input: "pose_exp_net/cnv3/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv3/weights/Adam_1/read" + op: "Identity" + input: "pose_exp_net/cnv3/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv3/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 64 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/cnv3/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv3/biases/Adam/Assign" + op: "Assign" + input: "pose_exp_net/cnv3/biases/Adam" + input: "pose_exp_net/cnv3/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv3/biases/Adam/read" + op: "Identity" + input: "pose_exp_net/cnv3/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv3/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 64 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/cnv3/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 64 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv3/biases/Adam_1/Assign" + op: "Assign" + input: "pose_exp_net/cnv3/biases/Adam_1" + input: "pose_exp_net/cnv3/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv3/biases/Adam_1/read" + op: "Identity" + input: "pose_exp_net/cnv3/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv4/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000@\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "pose_exp_net/cnv4/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + 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: "pose_exp_net/cnv4/weights/Adam/Initializer/zeros" + op: "Fill" + input: "pose_exp_net/cnv4/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "pose_exp_net/cnv4/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "pose_exp_net/cnv4/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv4/weights/Adam/Assign" + op: "Assign" + input: "pose_exp_net/cnv4/weights/Adam" + input: "pose_exp_net/cnv4/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv4/weights/Adam/read" + op: "Identity" + input: "pose_exp_net/cnv4/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv4/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000@\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "pose_exp_net/cnv4/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + 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: "pose_exp_net/cnv4/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "pose_exp_net/cnv4/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "pose_exp_net/cnv4/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "pose_exp_net/cnv4/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv4/weights/Adam_1/Assign" + op: "Assign" + input: "pose_exp_net/cnv4/weights/Adam_1" + input: "pose_exp_net/cnv4/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv4/weights/Adam_1/read" + op: "Identity" + input: "pose_exp_net/cnv4/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv4/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 128 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/cnv4/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv4/biases/Adam/Assign" + op: "Assign" + input: "pose_exp_net/cnv4/biases/Adam" + input: "pose_exp_net/cnv4/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv4/biases/Adam/read" + op: "Identity" + input: "pose_exp_net/cnv4/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv4/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 128 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/cnv4/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 128 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv4/biases/Adam_1/Assign" + op: "Assign" + input: "pose_exp_net/cnv4/biases/Adam_1" + input: "pose_exp_net/cnv4/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv4/biases/Adam_1/read" + op: "Identity" + input: "pose_exp_net/cnv4/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv5/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\000\001\000\000" + } + } + } +} +node { + name: "pose_exp_net/cnv5/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + 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: "pose_exp_net/cnv5/weights/Adam/Initializer/zeros" + op: "Fill" + input: "pose_exp_net/cnv5/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "pose_exp_net/cnv5/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "pose_exp_net/cnv5/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv5/weights/Adam/Assign" + op: "Assign" + input: "pose_exp_net/cnv5/weights/Adam" + input: "pose_exp_net/cnv5/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv5/weights/Adam/read" + op: "Identity" + input: "pose_exp_net/cnv5/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv5/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\000\001\000\000" + } + } + } +} +node { + name: "pose_exp_net/cnv5/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + 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: "pose_exp_net/cnv5/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "pose_exp_net/cnv5/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "pose_exp_net/cnv5/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "pose_exp_net/cnv5/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv5/weights/Adam_1/Assign" + op: "Assign" + input: "pose_exp_net/cnv5/weights/Adam_1" + input: "pose_exp_net/cnv5/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv5/weights/Adam_1/read" + op: "Identity" + input: "pose_exp_net/cnv5/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv5/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/cnv5/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv5/biases/Adam/Assign" + op: "Assign" + input: "pose_exp_net/cnv5/biases/Adam" + input: "pose_exp_net/cnv5/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv5/biases/Adam/read" + op: "Identity" + input: "pose_exp_net/cnv5/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/cnv5/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/cnv5/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/cnv5/biases/Adam_1/Assign" + op: "Assign" + input: "pose_exp_net/cnv5/biases/Adam_1" + input: "pose_exp_net/cnv5/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/cnv5/biases/Adam_1/read" + op: "Identity" + input: "pose_exp_net/cnv5/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\001\000\000" + } + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + 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: "pose_exp_net/pose/cnv6/weights/Adam/Initializer/zeros" + op: "Fill" + input: "pose_exp_net/pose/cnv6/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "pose_exp_net/pose/cnv6/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights/Adam/Assign" + op: "Assign" + input: "pose_exp_net/pose/cnv6/weights/Adam" + input: "pose_exp_net/pose/cnv6/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights/Adam/read" + op: "Identity" + input: "pose_exp_net/pose/cnv6/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\001\000\000" + } + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + 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: "pose_exp_net/pose/cnv6/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "pose_exp_net/pose/cnv6/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "pose_exp_net/pose/cnv6/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights/Adam_1/Assign" + op: "Assign" + input: "pose_exp_net/pose/cnv6/weights/Adam_1" + input: "pose_exp_net/pose/cnv6/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/pose/cnv6/weights/Adam_1/read" + op: "Identity" + input: "pose_exp_net/pose/cnv6/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/cnv6/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/pose/cnv6/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/pose/cnv6/biases/Adam/Assign" + op: "Assign" + input: "pose_exp_net/pose/cnv6/biases/Adam" + input: "pose_exp_net/pose/cnv6/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/pose/cnv6/biases/Adam/read" + op: "Identity" + input: "pose_exp_net/pose/cnv6/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/cnv6/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/pose/cnv6/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/pose/cnv6/biases/Adam_1/Assign" + op: "Assign" + input: "pose_exp_net/pose/cnv6/biases/Adam_1" + input: "pose_exp_net/pose/cnv6/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/pose/cnv6/biases/Adam_1/read" + op: "Identity" + input: "pose_exp_net/pose/cnv6/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\001\000\000" + } + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + 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: "pose_exp_net/pose/cnv7/weights/Adam/Initializer/zeros" + op: "Fill" + input: "pose_exp_net/pose/cnv7/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "pose_exp_net/pose/cnv7/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights/Adam/Assign" + op: "Assign" + input: "pose_exp_net/pose/cnv7/weights/Adam" + input: "pose_exp_net/pose/cnv7/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights/Adam/read" + op: "Identity" + input: "pose_exp_net/pose/cnv7/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\001\000\000" + } + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + 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: "pose_exp_net/pose/cnv7/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "pose_exp_net/pose/cnv7/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "pose_exp_net/pose/cnv7/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights/Adam_1/Assign" + op: "Assign" + input: "pose_exp_net/pose/cnv7/weights/Adam_1" + input: "pose_exp_net/pose/cnv7/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/pose/cnv7/weights/Adam_1/read" + op: "Identity" + input: "pose_exp_net/pose/cnv7/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/cnv7/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/pose/cnv7/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/pose/cnv7/biases/Adam/Assign" + op: "Assign" + input: "pose_exp_net/pose/cnv7/biases/Adam" + input: "pose_exp_net/pose/cnv7/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/pose/cnv7/biases/Adam/read" + op: "Identity" + input: "pose_exp_net/pose/cnv7/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/cnv7/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/pose/cnv7/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/pose/cnv7/biases/Adam_1/Assign" + op: "Assign" + input: "pose_exp_net/pose/cnv7/biases/Adam_1" + input: "pose_exp_net/pose/cnv7/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/pose/cnv7/biases/Adam_1/read" + op: "Identity" + input: "pose_exp_net/pose/cnv7/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/pred/weights/Adam/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\000\001\000\000\014\000\000\000" + } + } + } +} +node { + name: "pose_exp_net/pose/pred/weights/Adam/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + 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: "pose_exp_net/pose/pred/weights/Adam/Initializer/zeros" + op: "Fill" + input: "pose_exp_net/pose/pred/weights/Adam/Initializer/zeros/shape_as_tensor" + input: "pose_exp_net/pose/pred/weights/Adam/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "pose_exp_net/pose/pred/weights/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/pose/pred/weights/Adam/Assign" + op: "Assign" + input: "pose_exp_net/pose/pred/weights/Adam" + input: "pose_exp_net/pose/pred/weights/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/pose/pred/weights/Adam/read" + op: "Identity" + input: "pose_exp_net/pose/pred/weights/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/pred/weights/Adam_1/Initializer/zeros/shape_as_tensor" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\000\001\000\000\014\000\000\000" + } + } + } +} +node { + name: "pose_exp_net/pose/pred/weights/Adam_1/Initializer/zeros/Const" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + 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: "pose_exp_net/pose/pred/weights/Adam_1/Initializer/zeros" + op: "Fill" + input: "pose_exp_net/pose/pred/weights/Adam_1/Initializer/zeros/shape_as_tensor" + input: "pose_exp_net/pose/pred/weights/Adam_1/Initializer/zeros/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "pose_exp_net/pose/pred/weights/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/pose/pred/weights/Adam_1/Assign" + op: "Assign" + input: "pose_exp_net/pose/pred/weights/Adam_1" + input: "pose_exp_net/pose/pred/weights/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/pose/pred/weights/Adam_1/read" + op: "Identity" + input: "pose_exp_net/pose/pred/weights/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/pred/biases/Adam/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 12 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 12 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/pose/pred/biases/Adam" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 12 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 12 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/pose/pred/biases/Adam/Assign" + op: "Assign" + input: "pose_exp_net/pose/pred/biases/Adam" + input: "pose_exp_net/pose/pred/biases/Adam/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 12 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/pose/pred/biases/Adam/read" + op: "Identity" + input: "pose_exp_net/pose/pred/biases/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 12 + } + } + } + } + } +} +node { + name: "pose_exp_net/pose/pred/biases/Adam_1/Initializer/zeros" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 12 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 12 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "pose_exp_net/pose/pred/biases/Adam_1" + op: "VariableV2" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 12 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 12 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "pose_exp_net/pose/pred/biases/Adam_1/Assign" + op: "Assign" + input: "pose_exp_net/pose/pred/biases/Adam_1" + input: "pose_exp_net/pose/pred/biases/Adam_1/Initializer/zeros" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 12 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "pose_exp_net/pose/pred/biases/Adam_1/read" + op: "Identity" + input: "pose_exp_net/pose/pred/biases/Adam_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 12 + } + } + } + } + } +} +node { + name: "train_op/Adam/learning_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.00019999999494757503 + } + } + } +} +node { + name: "train_op/Adam/beta1" + 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.8999999761581421 + } + } + } +} +node { + name: "train_op/Adam/beta2" + 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.9990000128746033 + } + } + } +} +node { + name: "train_op/Adam/epsilon" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 9.99999993922529e-09 + } + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv1/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv1/weights" + input: "depth_net/cnv1/weights/Adam" + input: "depth_net/cnv1/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv1/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv1/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv1/biases" + input: "depth_net/cnv1/biases/Adam" + input: "depth_net/cnv1/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv1/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv1b/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv1b/weights" + input: "depth_net/cnv1b/weights/Adam" + input: "depth_net/cnv1b/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv1b/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv1b/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv1b/biases" + input: "depth_net/cnv1b/biases/Adam" + input: "depth_net/cnv1b/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv1b/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv2/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv2/weights" + input: "depth_net/cnv2/weights/Adam" + input: "depth_net/cnv2/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv2/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv2/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv2/biases" + input: "depth_net/cnv2/biases/Adam" + input: "depth_net/cnv2/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv2/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv2b/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv2b/weights" + input: "depth_net/cnv2b/weights/Adam" + input: "depth_net/cnv2b/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv2b/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv2b/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv2b/biases" + input: "depth_net/cnv2b/biases/Adam" + input: "depth_net/cnv2b/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv2b/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv3/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv3/weights" + input: "depth_net/cnv3/weights/Adam" + input: "depth_net/cnv3/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv3/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv3/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv3/biases" + input: "depth_net/cnv3/biases/Adam" + input: "depth_net/cnv3/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv3/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv3b/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv3b/weights" + input: "depth_net/cnv3b/weights/Adam" + input: "depth_net/cnv3b/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv3b/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv3b/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv3b/biases" + input: "depth_net/cnv3b/biases/Adam" + input: "depth_net/cnv3b/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv3b/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv4/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv4/weights" + input: "depth_net/cnv4/weights/Adam" + input: "depth_net/cnv4/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv4/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv4/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv4/biases" + input: "depth_net/cnv4/biases/Adam" + input: "depth_net/cnv4/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv4/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv4b/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv4b/weights" + input: "depth_net/cnv4b/weights/Adam" + input: "depth_net/cnv4b/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv4b/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv4b/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv4b/biases" + input: "depth_net/cnv4b/biases/Adam" + input: "depth_net/cnv4b/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv4b/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv5/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv5/weights" + input: "depth_net/cnv5/weights/Adam" + input: "depth_net/cnv5/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv5/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv5/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv5/biases" + input: "depth_net/cnv5/biases/Adam" + input: "depth_net/cnv5/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv5/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv5b/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv5b/weights" + input: "depth_net/cnv5b/weights/Adam" + input: "depth_net/cnv5b/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv5b/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv5b/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv5b/biases" + input: "depth_net/cnv5b/biases/Adam" + input: "depth_net/cnv5b/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv5b/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv6/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv6/weights" + input: "depth_net/cnv6/weights/Adam" + input: "depth_net/cnv6/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv6/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv6/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv6/biases" + input: "depth_net/cnv6/biases/Adam" + input: "depth_net/cnv6/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv6/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv6b/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv6b/weights" + input: "depth_net/cnv6b/weights/Adam" + input: "depth_net/cnv6b/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv6b/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv6b/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv6b/biases" + input: "depth_net/cnv6b/biases/Adam" + input: "depth_net/cnv6b/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv6b/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv7/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv7/weights" + input: "depth_net/cnv7/weights/Adam" + input: "depth_net/cnv7/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv7/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv7/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv7/biases" + input: "depth_net/cnv7/biases/Adam" + input: "depth_net/cnv7/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv7/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv7b/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv7b/weights" + input: "depth_net/cnv7b/weights/Adam" + input: "depth_net/cnv7b/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv7b/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/cnv7b/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/cnv7b/biases" + input: "depth_net/cnv7b/biases/Adam" + input: "depth_net/cnv7b/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/cnv7b/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/upcnv7/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/upcnv7/weights" + input: "depth_net/upcnv7/weights/Adam" + input: "depth_net/upcnv7/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/upcnv7/conv2d_transpose_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/upcnv7/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/upcnv7/biases" + input: "depth_net/upcnv7/biases/Adam" + input: "depth_net/upcnv7/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/upcnv7/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/icnv7/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/icnv7/weights" + input: "depth_net/icnv7/weights/Adam" + input: "depth_net/icnv7/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/icnv7/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/icnv7/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/icnv7/biases" + input: "depth_net/icnv7/biases/Adam" + input: "depth_net/icnv7/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/icnv7/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/upcnv6/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/upcnv6/weights" + input: "depth_net/upcnv6/weights/Adam" + input: "depth_net/upcnv6/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/upcnv6/conv2d_transpose_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/upcnv6/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/upcnv6/biases" + input: "depth_net/upcnv6/biases/Adam" + input: "depth_net/upcnv6/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/upcnv6/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/icnv6/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/icnv6/weights" + input: "depth_net/icnv6/weights/Adam" + input: "depth_net/icnv6/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/icnv6/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/icnv6/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/icnv6/biases" + input: "depth_net/icnv6/biases/Adam" + input: "depth_net/icnv6/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/icnv6/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/upcnv5/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/upcnv5/weights" + input: "depth_net/upcnv5/weights/Adam" + input: "depth_net/upcnv5/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/upcnv5/conv2d_transpose_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/upcnv5/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/upcnv5/biases" + input: "depth_net/upcnv5/biases/Adam" + input: "depth_net/upcnv5/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/upcnv5/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/icnv5/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/icnv5/weights" + input: "depth_net/icnv5/weights/Adam" + input: "depth_net/icnv5/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/icnv5/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/icnv5/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/icnv5/biases" + input: "depth_net/icnv5/biases/Adam" + input: "depth_net/icnv5/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/icnv5/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/upcnv4/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/upcnv4/weights" + input: "depth_net/upcnv4/weights/Adam" + input: "depth_net/upcnv4/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/upcnv4/conv2d_transpose_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/upcnv4/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/upcnv4/biases" + input: "depth_net/upcnv4/biases/Adam" + input: "depth_net/upcnv4/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/upcnv4/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/icnv4/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/icnv4/weights" + input: "depth_net/icnv4/weights/Adam" + input: "depth_net/icnv4/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/icnv4/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/icnv4/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/icnv4/biases" + input: "depth_net/icnv4/biases/Adam" + input: "depth_net/icnv4/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/icnv4/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/disp4/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/disp4/weights" + input: "depth_net/disp4/weights/Adam" + input: "depth_net/disp4/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/disp4/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/disp4/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/disp4/biases" + input: "depth_net/disp4/biases/Adam" + input: "depth_net/disp4/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/disp4/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/upcnv3/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/upcnv3/weights" + input: "depth_net/upcnv3/weights/Adam" + input: "depth_net/upcnv3/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/upcnv3/conv2d_transpose_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/upcnv3/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/upcnv3/biases" + input: "depth_net/upcnv3/biases/Adam" + input: "depth_net/upcnv3/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/upcnv3/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/icnv3/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/icnv3/weights" + input: "depth_net/icnv3/weights/Adam" + input: "depth_net/icnv3/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/icnv3/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/icnv3/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/icnv3/biases" + input: "depth_net/icnv3/biases/Adam" + input: "depth_net/icnv3/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/icnv3/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/disp3/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/disp3/weights" + input: "depth_net/disp3/weights/Adam" + input: "depth_net/disp3/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/disp3/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/disp3/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/disp3/biases" + input: "depth_net/disp3/biases/Adam" + input: "depth_net/disp3/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/disp3/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/upcnv2/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/upcnv2/weights" + input: "depth_net/upcnv2/weights/Adam" + input: "depth_net/upcnv2/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/upcnv2/conv2d_transpose_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/upcnv2/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/upcnv2/biases" + input: "depth_net/upcnv2/biases/Adam" + input: "depth_net/upcnv2/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/upcnv2/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/icnv2/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/icnv2/weights" + input: "depth_net/icnv2/weights/Adam" + input: "depth_net/icnv2/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/icnv2/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/icnv2/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/icnv2/biases" + input: "depth_net/icnv2/biases/Adam" + input: "depth_net/icnv2/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/icnv2/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/disp2/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/disp2/weights" + input: "depth_net/disp2/weights/Adam" + input: "depth_net/disp2/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/disp2/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/disp2/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/disp2/biases" + input: "depth_net/disp2/biases/Adam" + input: "depth_net/disp2/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/disp2/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/upcnv1/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/upcnv1/weights" + input: "depth_net/upcnv1/weights/Adam" + input: "depth_net/upcnv1/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/upcnv1/conv2d_transpose_grad/tuple/control_dependency" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/upcnv1/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/upcnv1/biases" + input: "depth_net/upcnv1/biases/Adam" + input: "depth_net/upcnv1/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/upcnv1/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/icnv1/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/icnv1/weights" + input: "depth_net/icnv1/weights/Adam" + input: "depth_net/icnv1/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/icnv1/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/icnv1/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/icnv1/biases" + input: "depth_net/icnv1/biases/Adam" + input: "depth_net/icnv1/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/icnv1/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/disp1/weights/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/disp1/weights" + input: "depth_net/disp1/weights/Adam" + input: "depth_net/disp1/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/disp1/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_depth_net/disp1/biases/ApplyAdam" + op: "ApplyAdam" + input: "depth_net/disp1/biases" + input: "depth_net/disp1/biases/Adam" + input: "depth_net/disp1/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/depth_prediction/depth_net/disp1/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_pose_exp_net/cnv1/weights/ApplyAdam" + op: "ApplyAdam" + input: "pose_exp_net/cnv1/weights" + input: "pose_exp_net/cnv1/weights/Adam" + input: "pose_exp_net/cnv1/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_pose_exp_net/cnv1/biases/ApplyAdam" + op: "ApplyAdam" + input: "pose_exp_net/cnv1/biases" + input: "pose_exp_net/cnv1/biases/Adam" + input: "pose_exp_net/cnv1/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv1/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_pose_exp_net/cnv2/weights/ApplyAdam" + op: "ApplyAdam" + input: "pose_exp_net/cnv2/weights" + input: "pose_exp_net/cnv2/weights/Adam" + input: "pose_exp_net/cnv2/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_pose_exp_net/cnv2/biases/ApplyAdam" + op: "ApplyAdam" + input: "pose_exp_net/cnv2/biases" + input: "pose_exp_net/cnv2/biases/Adam" + input: "pose_exp_net/cnv2/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv2/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_pose_exp_net/cnv3/weights/ApplyAdam" + op: "ApplyAdam" + input: "pose_exp_net/cnv3/weights" + input: "pose_exp_net/cnv3/weights/Adam" + input: "pose_exp_net/cnv3/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_pose_exp_net/cnv3/biases/ApplyAdam" + op: "ApplyAdam" + input: "pose_exp_net/cnv3/biases" + input: "pose_exp_net/cnv3/biases/Adam" + input: "pose_exp_net/cnv3/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv3/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_pose_exp_net/cnv4/weights/ApplyAdam" + op: "ApplyAdam" + input: "pose_exp_net/cnv4/weights" + input: "pose_exp_net/cnv4/weights/Adam" + input: "pose_exp_net/cnv4/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_pose_exp_net/cnv4/biases/ApplyAdam" + op: "ApplyAdam" + input: "pose_exp_net/cnv4/biases" + input: "pose_exp_net/cnv4/biases/Adam" + input: "pose_exp_net/cnv4/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv4/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_pose_exp_net/cnv5/weights/ApplyAdam" + op: "ApplyAdam" + input: "pose_exp_net/cnv5/weights" + input: "pose_exp_net/cnv5/weights/Adam" + input: "pose_exp_net/cnv5/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_pose_exp_net/cnv5/biases/ApplyAdam" + op: "ApplyAdam" + input: "pose_exp_net/cnv5/biases" + input: "pose_exp_net/cnv5/biases/Adam" + input: "pose_exp_net/cnv5/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/cnv5/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_pose_exp_net/pose/cnv6/weights/ApplyAdam" + op: "ApplyAdam" + input: "pose_exp_net/pose/cnv6/weights" + input: "pose_exp_net/pose/cnv6/weights/Adam" + input: "pose_exp_net/pose/cnv6/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_pose_exp_net/pose/cnv6/biases/ApplyAdam" + op: "ApplyAdam" + input: "pose_exp_net/pose/cnv6/biases" + input: "pose_exp_net/pose/cnv6/biases/Adam" + input: "pose_exp_net/pose/cnv6/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv6/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_pose_exp_net/pose/cnv7/weights/ApplyAdam" + op: "ApplyAdam" + input: "pose_exp_net/pose/cnv7/weights" + input: "pose_exp_net/pose/cnv7/weights/Adam" + input: "pose_exp_net/pose/cnv7/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_pose_exp_net/pose/cnv7/biases/ApplyAdam" + op: "ApplyAdam" + input: "pose_exp_net/pose/cnv7/biases" + input: "pose_exp_net/pose/cnv7/biases/Adam" + input: "pose_exp_net/pose/cnv7/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/cnv7/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_pose_exp_net/pose/pred/weights/ApplyAdam" + op: "ApplyAdam" + input: "pose_exp_net/pose/pred/weights" + input: "pose_exp_net/pose/pred/weights/Adam" + input: "pose_exp_net/pose/pred/weights/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/Conv2D_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/update_pose_exp_net/pose/pred/biases/ApplyAdam" + op: "ApplyAdam" + input: "pose_exp_net/pose/pred/biases" + input: "pose_exp_net/pose/pred/biases/Adam" + input: "pose_exp_net/pose/pred/biases/Adam_1" + input: "train_op/beta1_power/read" + input: "train_op/beta2_power/read" + input: "train_op/Adam/learning_rate" + input: "train_op/Adam/beta1" + input: "train_op/Adam/beta2" + input: "train_op/Adam/epsilon" + input: "train_op/gradients/pose_and_explainability_prediction/pose_exp_net/pose/pred/BiasAdd_grad/tuple/control_dependency_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 12 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "use_nesterov" + value { + b: false + } + } +} +node { + name: "train_op/Adam/mul" + op: "Mul" + input: "train_op/beta1_power/read" + input: "train_op/Adam/beta1" + input: "^train_op/Adam/update_depth_net/cnv1/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv1/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv1b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv1b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv2/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv2/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv2b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv2b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv3/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv3/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv3b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv3b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv4/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv4/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv4b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv4b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv5/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv5/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv5b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv5b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv6/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv6/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv6b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv6b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv7/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv7/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv7b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv7b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp1/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp1/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp2/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp2/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp3/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp3/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp4/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp4/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv1/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv1/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv2/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv2/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv3/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv3/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv4/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv4/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv5/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv5/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv6/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv6/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv7/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv7/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv1/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv1/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv2/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv2/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv3/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv3/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv4/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv4/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv5/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv5/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv6/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv6/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv7/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv7/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv1/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv1/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv2/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv2/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv3/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv3/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv4/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv4/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv5/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv5/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/pose/cnv6/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/pose/cnv6/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/pose/cnv7/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/pose/cnv7/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/pose/pred/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/pose/pred/weights/ApplyAdam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/Adam/Assign" + op: "Assign" + input: "train_op/beta1_power" + input: "train_op/Adam/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "train_op/Adam/mul_1" + op: "Mul" + input: "train_op/beta2_power/read" + input: "train_op/Adam/beta2" + input: "^train_op/Adam/update_depth_net/cnv1/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv1/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv1b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv1b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv2/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv2/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv2b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv2b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv3/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv3/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv3b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv3b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv4/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv4/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv4b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv4b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv5/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv5/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv5b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv5b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv6/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv6/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv6b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv6b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv7/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv7/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv7b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv7b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp1/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp1/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp2/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp2/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp3/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp3/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp4/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp4/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv1/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv1/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv2/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv2/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv3/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv3/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv4/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv4/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv5/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv5/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv6/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv6/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv7/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv7/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv1/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv1/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv2/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv2/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv3/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv3/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv4/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv4/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv5/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv5/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv6/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv6/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv7/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv7/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv1/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv1/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv2/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv2/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv3/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv3/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv4/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv4/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv5/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv5/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/pose/cnv6/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/pose/cnv6/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/pose/cnv7/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/pose/cnv7/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/pose/pred/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/pose/pred/weights/ApplyAdam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/Adam/Assign_1" + op: "Assign" + input: "train_op/beta2_power" + input: "train_op/Adam/mul_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "use_locking" + value { + b: false + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "train_op/Adam/update" + op: "NoOp" + input: "^train_op/Adam/Assign" + input: "^train_op/Adam/Assign_1" + input: "^train_op/Adam/update_depth_net/cnv1/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv1/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv1b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv1b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv2/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv2/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv2b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv2b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv3/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv3/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv3b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv3b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv4/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv4/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv4b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv4b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv5/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv5/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv5b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv5b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv6/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv6/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv6b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv6b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv7/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv7/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv7b/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/cnv7b/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp1/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp1/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp2/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp2/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp3/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp3/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp4/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/disp4/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv1/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv1/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv2/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv2/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv3/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv3/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv4/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv4/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv5/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv5/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv6/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv6/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv7/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/icnv7/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv1/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv1/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv2/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv2/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv3/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv3/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv4/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv4/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv5/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv5/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv6/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv6/weights/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv7/biases/ApplyAdam" + input: "^train_op/Adam/update_depth_net/upcnv7/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv1/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv1/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv2/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv2/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv3/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv3/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv4/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv4/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv5/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/cnv5/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/pose/cnv6/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/pose/cnv6/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/pose/cnv7/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/pose/cnv7/weights/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/pose/pred/biases/ApplyAdam" + input: "^train_op/Adam/update_pose_exp_net/pose/pred/weights/ApplyAdam" +} +node { + name: "train_op/Adam/value" + op: "Const" + input: "^train_op/Adam/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: "train_op/Adam" + op: "AssignAdd" + input: "global_step" + input: "train_op/Adam/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: "train_op/train_op/CheckNumerics" + op: "CheckNumerics" + input: "compute_loss/add_57" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "message" + value { + s: "LossTensor is inf or nan" + } + } +} +node { + name: "train_op/train_op/control_dependency" + op: "Identity" + input: "train_op/train_op/CheckNumerics" + input: "^train_op/Adam" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/train_op/CheckNumerics" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/global_step/initial_value" + 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: "train_op/global_step" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "shape" + value { + shape { + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "train_op/global_step/Assign" + op: "Assign" + input: "train_op/global_step" + input: "train_op/global_step/initial_value" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/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: "train_op/global_step/read" + op: "Identity" + input: "train_op/global_step" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/global_step" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/add/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: "train_op/add" + op: "Add" + input: "train_op/global_step/read" + input: "train_op/add/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "train_op/Assign" + op: "Assign" + input: "train_op/global_step" + input: "train_op/add" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/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: "total_loss/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: "total_loss" + } + } + } +} +node { + name: "total_loss" + op: "ScalarSummary" + input: "total_loss/tags" + input: "compute_loss/add_57" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "pixel_loss/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: "pixel_loss" + } + } + } +} +node { + name: "pixel_loss" + op: "ScalarSummary" + input: "pixel_loss/tags" + input: "compute_loss/add_55" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "smooth_loss/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: "smooth_loss" + } + } + } +} +node { + name: "smooth_loss" + op: "ScalarSummary" + input: "smooth_loss/tags" + input: "compute_loss/add_45" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "exp_loss/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: "exp_loss" + } + } + } +} +node { + name: "exp_loss/values" + 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: "exp_loss" + op: "ScalarSummary" + input: "exp_loss/tags" + input: "exp_loss/values" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "scale0_depth/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: "scale0_depth" + } + } + } +} +node { + name: "scale0_depth" + op: "HistogramSummary" + input: "scale0_depth/tag" + input: "depth_prediction/truediv" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "truediv/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "truediv" + op: "RealDiv" + input: "truediv/x" + input: "depth_prediction/truediv" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "scale0_disparity_image/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: "scale0_disparity_image" + } + } + } +} +node { + name: "scale0_disparity_image" + op: "ImageSummary" + input: "scale0_disparity_image/tag" + input: "truediv" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "add/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "add" + op: "Add" + input: "compute_loss/ResizeArea" + input: "add/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_1/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_1" + op: "RealDiv" + input: "add" + input: "truediv_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image/Mul" + op: "Mul" + input: "truediv_1" + input: "convert_image/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image" + op: "Cast" + input: "convert_image/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale0_target_image/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: "scale0_target_image" + } + } + } +} +node { + name: "scale0_target_image" + op: "ImageSummary" + input: "scale0_target_image/tag" + input: "convert_image" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "strided_slice/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice" + op: "StridedSlice" + input: "compute_loss/ResizeArea_1" + input: "strided_slice/stack" + input: "strided_slice/stack_1" + input: "strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "add_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: 1.0 + } + } + } +} +node { + name: "add_1" + op: "Add" + input: "strided_slice" + input: "add_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_2/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_2" + op: "RealDiv" + input: "add_1" + input: "truediv_2/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_1/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_1/Mul" + op: "Mul" + input: "truediv_2" + input: "convert_image_1/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_1" + op: "Cast" + input: "convert_image_1/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale0_source_image_0/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: "scale0_source_image_0" + } + } + } +} +node { + name: "scale0_source_image_0" + op: "ImageSummary" + input: "scale0_source_image_0/tag" + input: "convert_image_1" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_1/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "strided_slice_1/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_1/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_1" + op: "StridedSlice" + input: "compute_loss/concat_36" + input: "strided_slice_1/stack" + input: "strided_slice_1/stack_1" + input: "strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "add_2/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "add_2" + op: "Add" + input: "strided_slice_1" + input: "add_2/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_3/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_3" + op: "RealDiv" + input: "add_2" + input: "truediv_3/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_2/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_2/Mul" + op: "Mul" + input: "truediv_3" + input: "convert_image_2/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_2" + op: "Cast" + input: "convert_image_2/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale0_projected_image_0/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: "scale0_projected_image_0" + } + } + } +} +node { + name: "scale0_projected_image_0" + op: "ImageSummary" + input: "scale0_projected_image_0/tag" + input: "convert_image_2" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_2/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "strided_slice_2/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_2/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_2" + op: "StridedSlice" + input: "compute_loss/concat_37" + input: "strided_slice_2/stack" + input: "strided_slice_2/stack_1" + input: "strided_slice_2/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "sub/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: 1.0 + } + } + } +} +node { + name: "sub" + op: "Sub" + input: "strided_slice_2" + input: "sub/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "clip_by_value/Minimum/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: 1.0 + } + } + } +} +node { + name: "clip_by_value/Minimum" + op: "Minimum" + input: "sub" + input: "clip_by_value/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "clip_by_value/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: -1.0 + } + } + } +} +node { + name: "clip_by_value" + op: "Maximum" + input: "clip_by_value/Minimum" + input: "clip_by_value/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "add_3/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "add_3" + op: "Add" + input: "clip_by_value" + input: "add_3/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_4/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_4" + op: "RealDiv" + input: "add_3" + input: "truediv_4/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_3/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_3/Mul" + op: "Mul" + input: "truediv_4" + input: "convert_image_3/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_3" + op: "Cast" + input: "convert_image_3/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale0_proj_error_0/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: "scale0_proj_error_0" + } + } + } +} +node { + name: "scale0_proj_error_0" + op: "ImageSummary" + input: "scale0_proj_error_0/tag" + input: "convert_image_3" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_3/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_3/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "strided_slice_3/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_3" + op: "StridedSlice" + input: "compute_loss/ResizeArea_1" + input: "strided_slice_3/stack" + input: "strided_slice_3/stack_1" + input: "strided_slice_3/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "add_4/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "add_4" + op: "Add" + input: "strided_slice_3" + input: "add_4/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_5/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_5" + op: "RealDiv" + input: "add_4" + input: "truediv_5/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_4/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_4/Mul" + op: "Mul" + input: "truediv_5" + input: "convert_image_4/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_4" + op: "Cast" + input: "convert_image_4/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale0_source_image_1/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: "scale0_source_image_1" + } + } + } +} +node { + name: "scale0_source_image_1" + op: "ImageSummary" + input: "scale0_source_image_1/tag" + input: "convert_image_4" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_4/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_4/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "strided_slice_4/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_4" + op: "StridedSlice" + input: "compute_loss/concat_36" + input: "strided_slice_4/stack" + input: "strided_slice_4/stack_1" + input: "strided_slice_4/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "add_5/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "add_5" + op: "Add" + input: "strided_slice_4" + input: "add_5/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_6/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_6" + op: "RealDiv" + input: "add_5" + input: "truediv_6/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_5/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_5/Mul" + op: "Mul" + input: "truediv_6" + input: "convert_image_5/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_5" + op: "Cast" + input: "convert_image_5/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale0_projected_image_1/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: "scale0_projected_image_1" + } + } + } +} +node { + name: "scale0_projected_image_1" + op: "ImageSummary" + input: "scale0_projected_image_1/tag" + input: "convert_image_5" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_5/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_5/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "strided_slice_5/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_5" + op: "StridedSlice" + input: "compute_loss/concat_37" + input: "strided_slice_5/stack" + input: "strided_slice_5/stack_1" + input: "strided_slice_5/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "sub_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: 1.0 + } + } + } +} +node { + name: "sub_1" + op: "Sub" + input: "strided_slice_5" + input: "sub_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "clip_by_value_1/Minimum/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: 1.0 + } + } + } +} +node { + name: "clip_by_value_1/Minimum" + op: "Minimum" + input: "sub_1" + input: "clip_by_value_1/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "clip_by_value_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: -1.0 + } + } + } +} +node { + name: "clip_by_value_1" + op: "Maximum" + input: "clip_by_value_1/Minimum" + input: "clip_by_value_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "add_6/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "add_6" + op: "Add" + input: "clip_by_value_1" + input: "add_6/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_7/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_7" + op: "RealDiv" + input: "add_6" + input: "truediv_7/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_6/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_6/Mul" + op: "Mul" + input: "truediv_7" + input: "convert_image_6/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_6" + op: "Cast" + input: "convert_image_6/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 128 + } + dim { + size: 416 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale0_proj_error_1/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: "scale0_proj_error_1" + } + } + } +} +node { + name: "scale0_proj_error_1" + op: "ImageSummary" + input: "scale0_proj_error_1/tag" + input: "convert_image_6" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "scale1_depth/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: "scale1_depth" + } + } + } +} +node { + name: "scale1_depth" + op: "HistogramSummary" + input: "scale1_depth/tag" + input: "depth_prediction/truediv_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "truediv_8/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "truediv_8" + op: "RealDiv" + input: "truediv_8/x" + input: "depth_prediction/truediv_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "scale1_disparity_image/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: "scale1_disparity_image" + } + } + } +} +node { + name: "scale1_disparity_image" + op: "ImageSummary" + input: "scale1_disparity_image/tag" + input: "truediv_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "add_7/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "add_7" + op: "Add" + input: "compute_loss/ResizeArea_2" + input: "add_7/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_9/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_9" + op: "RealDiv" + input: "add_7" + input: "truediv_9/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_7/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_7/Mul" + op: "Mul" + input: "truediv_9" + input: "convert_image_7/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_7" + op: "Cast" + input: "convert_image_7/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale1_target_image/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: "scale1_target_image" + } + } + } +} +node { + name: "scale1_target_image" + op: "ImageSummary" + input: "scale1_target_image/tag" + input: "convert_image_7" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_6/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "strided_slice_6/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_6/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_6" + op: "StridedSlice" + input: "compute_loss/ResizeArea_3" + input: "strided_slice_6/stack" + input: "strided_slice_6/stack_1" + input: "strided_slice_6/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "add_8/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "add_8" + op: "Add" + input: "strided_slice_6" + input: "add_8/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_10/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_10" + op: "RealDiv" + input: "add_8" + input: "truediv_10/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_8/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_8/Mul" + op: "Mul" + input: "truediv_10" + input: "convert_image_8/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_8" + op: "Cast" + input: "convert_image_8/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale1_source_image_0/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: "scale1_source_image_0" + } + } + } +} +node { + name: "scale1_source_image_0" + op: "ImageSummary" + input: "scale1_source_image_0/tag" + input: "convert_image_8" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_7/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "strided_slice_7/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_7/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_7" + op: "StridedSlice" + input: "compute_loss/concat_74" + input: "strided_slice_7/stack" + input: "strided_slice_7/stack_1" + input: "strided_slice_7/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "add_9/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "add_9" + op: "Add" + input: "strided_slice_7" + input: "add_9/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_11/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_11" + op: "RealDiv" + input: "add_9" + input: "truediv_11/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_9/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_9/Mul" + op: "Mul" + input: "truediv_11" + input: "convert_image_9/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_9" + op: "Cast" + input: "convert_image_9/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale1_projected_image_0/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: "scale1_projected_image_0" + } + } + } +} +node { + name: "scale1_projected_image_0" + op: "ImageSummary" + input: "scale1_projected_image_0/tag" + input: "convert_image_9" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_8/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "strided_slice_8/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_8/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_8" + op: "StridedSlice" + input: "compute_loss/concat_75" + input: "strided_slice_8/stack" + input: "strided_slice_8/stack_1" + input: "strided_slice_8/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "sub_2/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "sub_2" + op: "Sub" + input: "strided_slice_8" + input: "sub_2/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "clip_by_value_2/Minimum/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: 1.0 + } + } + } +} +node { + name: "clip_by_value_2/Minimum" + op: "Minimum" + input: "sub_2" + input: "clip_by_value_2/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "clip_by_value_2/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: -1.0 + } + } + } +} +node { + name: "clip_by_value_2" + op: "Maximum" + input: "clip_by_value_2/Minimum" + input: "clip_by_value_2/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "add_10/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "add_10" + op: "Add" + input: "clip_by_value_2" + input: "add_10/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_12/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_12" + op: "RealDiv" + input: "add_10" + input: "truediv_12/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_10/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_10/Mul" + op: "Mul" + input: "truediv_12" + input: "convert_image_10/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_10" + op: "Cast" + input: "convert_image_10/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale1_proj_error_0/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: "scale1_proj_error_0" + } + } + } +} +node { + name: "scale1_proj_error_0" + op: "ImageSummary" + input: "scale1_proj_error_0/tag" + input: "convert_image_10" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_9/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_9/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "strided_slice_9/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_9" + op: "StridedSlice" + input: "compute_loss/ResizeArea_3" + input: "strided_slice_9/stack" + input: "strided_slice_9/stack_1" + input: "strided_slice_9/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "add_11/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: 1.0 + } + } + } +} +node { + name: "add_11" + op: "Add" + input: "strided_slice_9" + input: "add_11/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_13/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_13" + op: "RealDiv" + input: "add_11" + input: "truediv_13/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_11/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_11/Mul" + op: "Mul" + input: "truediv_13" + input: "convert_image_11/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_11" + op: "Cast" + input: "convert_image_11/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale1_source_image_1/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: "scale1_source_image_1" + } + } + } +} +node { + name: "scale1_source_image_1" + op: "ImageSummary" + input: "scale1_source_image_1/tag" + input: "convert_image_11" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_10/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_10/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "strided_slice_10/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_10" + op: "StridedSlice" + input: "compute_loss/concat_74" + input: "strided_slice_10/stack" + input: "strided_slice_10/stack_1" + input: "strided_slice_10/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "add_12/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "add_12" + op: "Add" + input: "strided_slice_10" + input: "add_12/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_14/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_14" + op: "RealDiv" + input: "add_12" + input: "truediv_14/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_12/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_12/Mul" + op: "Mul" + input: "truediv_14" + input: "convert_image_12/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_12" + op: "Cast" + input: "convert_image_12/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale1_projected_image_1/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: "scale1_projected_image_1" + } + } + } +} +node { + name: "scale1_projected_image_1" + op: "ImageSummary" + input: "scale1_projected_image_1/tag" + input: "convert_image_12" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_11/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_11/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "strided_slice_11/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_11" + op: "StridedSlice" + input: "compute_loss/concat_75" + input: "strided_slice_11/stack" + input: "strided_slice_11/stack_1" + input: "strided_slice_11/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "sub_3/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "sub_3" + op: "Sub" + input: "strided_slice_11" + input: "sub_3/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "clip_by_value_3/Minimum/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: 1.0 + } + } + } +} +node { + name: "clip_by_value_3/Minimum" + op: "Minimum" + input: "sub_3" + input: "clip_by_value_3/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "clip_by_value_3/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: -1.0 + } + } + } +} +node { + name: "clip_by_value_3" + op: "Maximum" + input: "clip_by_value_3/Minimum" + input: "clip_by_value_3/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "add_13/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: 1.0 + } + } + } +} +node { + name: "add_13" + op: "Add" + input: "clip_by_value_3" + input: "add_13/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_15/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_15" + op: "RealDiv" + input: "add_13" + input: "truediv_15/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_13/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_13/Mul" + op: "Mul" + input: "truediv_15" + input: "convert_image_13/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_13" + op: "Cast" + input: "convert_image_13/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 64 + } + dim { + size: 208 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale1_proj_error_1/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: "scale1_proj_error_1" + } + } + } +} +node { + name: "scale1_proj_error_1" + op: "ImageSummary" + input: "scale1_proj_error_1/tag" + input: "convert_image_13" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "scale2_depth/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: "scale2_depth" + } + } + } +} +node { + name: "scale2_depth" + op: "HistogramSummary" + input: "scale2_depth/tag" + input: "depth_prediction/truediv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "truediv_16/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "truediv_16" + op: "RealDiv" + input: "truediv_16/x" + input: "depth_prediction/truediv_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "scale2_disparity_image/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: "scale2_disparity_image" + } + } + } +} +node { + name: "scale2_disparity_image" + op: "ImageSummary" + input: "scale2_disparity_image/tag" + input: "truediv_16" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "add_14/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: 1.0 + } + } + } +} +node { + name: "add_14" + op: "Add" + input: "compute_loss/ResizeArea_4" + input: "add_14/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_17/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_17" + op: "RealDiv" + input: "add_14" + input: "truediv_17/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_14/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_14/Mul" + op: "Mul" + input: "truediv_17" + input: "convert_image_14/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_14" + op: "Cast" + input: "convert_image_14/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale2_target_image/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: "scale2_target_image" + } + } + } +} +node { + name: "scale2_target_image" + op: "ImageSummary" + input: "scale2_target_image/tag" + input: "convert_image_14" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_12/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "strided_slice_12/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_12/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_12" + op: "StridedSlice" + input: "compute_loss/ResizeArea_5" + input: "strided_slice_12/stack" + input: "strided_slice_12/stack_1" + input: "strided_slice_12/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "add_15/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: 1.0 + } + } + } +} +node { + name: "add_15" + op: "Add" + input: "strided_slice_12" + input: "add_15/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_18/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_18" + op: "RealDiv" + input: "add_15" + input: "truediv_18/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_15/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_15/Mul" + op: "Mul" + input: "truediv_18" + input: "convert_image_15/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_15" + op: "Cast" + input: "convert_image_15/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale2_source_image_0/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: "scale2_source_image_0" + } + } + } +} +node { + name: "scale2_source_image_0" + op: "ImageSummary" + input: "scale2_source_image_0/tag" + input: "convert_image_15" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_13/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "strided_slice_13/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_13/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_13" + op: "StridedSlice" + input: "compute_loss/concat_112" + input: "strided_slice_13/stack" + input: "strided_slice_13/stack_1" + input: "strided_slice_13/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "add_16/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: 1.0 + } + } + } +} +node { + name: "add_16" + op: "Add" + input: "strided_slice_13" + input: "add_16/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_19/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_19" + op: "RealDiv" + input: "add_16" + input: "truediv_19/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_16/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_16/Mul" + op: "Mul" + input: "truediv_19" + input: "convert_image_16/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_16" + op: "Cast" + input: "convert_image_16/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale2_projected_image_0/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: "scale2_projected_image_0" + } + } + } +} +node { + name: "scale2_projected_image_0" + op: "ImageSummary" + input: "scale2_projected_image_0/tag" + input: "convert_image_16" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_14/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "strided_slice_14/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_14/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_14" + op: "StridedSlice" + input: "compute_loss/concat_113" + input: "strided_slice_14/stack" + input: "strided_slice_14/stack_1" + input: "strided_slice_14/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "sub_4/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "sub_4" + op: "Sub" + input: "strided_slice_14" + input: "sub_4/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "clip_by_value_4/Minimum/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: 1.0 + } + } + } +} +node { + name: "clip_by_value_4/Minimum" + op: "Minimum" + input: "sub_4" + input: "clip_by_value_4/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "clip_by_value_4/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: -1.0 + } + } + } +} +node { + name: "clip_by_value_4" + op: "Maximum" + input: "clip_by_value_4/Minimum" + input: "clip_by_value_4/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "add_17/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: 1.0 + } + } + } +} +node { + name: "add_17" + op: "Add" + input: "clip_by_value_4" + input: "add_17/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_20/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_20" + op: "RealDiv" + input: "add_17" + input: "truediv_20/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_17/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_17/Mul" + op: "Mul" + input: "truediv_20" + input: "convert_image_17/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_17" + op: "Cast" + input: "convert_image_17/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale2_proj_error_0/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: "scale2_proj_error_0" + } + } + } +} +node { + name: "scale2_proj_error_0" + op: "ImageSummary" + input: "scale2_proj_error_0/tag" + input: "convert_image_17" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_15/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_15/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "strided_slice_15/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_15" + op: "StridedSlice" + input: "compute_loss/ResizeArea_5" + input: "strided_slice_15/stack" + input: "strided_slice_15/stack_1" + input: "strided_slice_15/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "add_18/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: 1.0 + } + } + } +} +node { + name: "add_18" + op: "Add" + input: "strided_slice_15" + input: "add_18/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_21/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_21" + op: "RealDiv" + input: "add_18" + input: "truediv_21/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_18/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_18/Mul" + op: "Mul" + input: "truediv_21" + input: "convert_image_18/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_18" + op: "Cast" + input: "convert_image_18/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale2_source_image_1/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: "scale2_source_image_1" + } + } + } +} +node { + name: "scale2_source_image_1" + op: "ImageSummary" + input: "scale2_source_image_1/tag" + input: "convert_image_18" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_16/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_16/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "strided_slice_16/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_16" + op: "StridedSlice" + input: "compute_loss/concat_112" + input: "strided_slice_16/stack" + input: "strided_slice_16/stack_1" + input: "strided_slice_16/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "add_19/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: 1.0 + } + } + } +} +node { + name: "add_19" + op: "Add" + input: "strided_slice_16" + input: "add_19/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_22/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_22" + op: "RealDiv" + input: "add_19" + input: "truediv_22/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_19/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_19/Mul" + op: "Mul" + input: "truediv_22" + input: "convert_image_19/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_19" + op: "Cast" + input: "convert_image_19/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale2_projected_image_1/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: "scale2_projected_image_1" + } + } + } +} +node { + name: "scale2_projected_image_1" + op: "ImageSummary" + input: "scale2_projected_image_1/tag" + input: "convert_image_19" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_17/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_17/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "strided_slice_17/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_17" + op: "StridedSlice" + input: "compute_loss/concat_113" + input: "strided_slice_17/stack" + input: "strided_slice_17/stack_1" + input: "strided_slice_17/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "sub_5/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "sub_5" + op: "Sub" + input: "strided_slice_17" + input: "sub_5/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "clip_by_value_5/Minimum/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: 1.0 + } + } + } +} +node { + name: "clip_by_value_5/Minimum" + op: "Minimum" + input: "sub_5" + input: "clip_by_value_5/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "clip_by_value_5/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: -1.0 + } + } + } +} +node { + name: "clip_by_value_5" + op: "Maximum" + input: "clip_by_value_5/Minimum" + input: "clip_by_value_5/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "add_20/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: 1.0 + } + } + } +} +node { + name: "add_20" + op: "Add" + input: "clip_by_value_5" + input: "add_20/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_23/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_23" + op: "RealDiv" + input: "add_20" + input: "truediv_23/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_20/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_20/Mul" + op: "Mul" + input: "truediv_23" + input: "convert_image_20/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_20" + op: "Cast" + input: "convert_image_20/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 32 + } + dim { + size: 104 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale2_proj_error_1/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: "scale2_proj_error_1" + } + } + } +} +node { + name: "scale2_proj_error_1" + op: "ImageSummary" + input: "scale2_proj_error_1/tag" + input: "convert_image_20" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "scale3_depth/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: "scale3_depth" + } + } + } +} +node { + name: "scale3_depth" + op: "HistogramSummary" + input: "scale3_depth/tag" + input: "depth_prediction/truediv_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "truediv_24/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "truediv_24" + op: "RealDiv" + input: "truediv_24/x" + input: "depth_prediction/truediv_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "scale3_disparity_image/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: "scale3_disparity_image" + } + } + } +} +node { + name: "scale3_disparity_image" + op: "ImageSummary" + input: "scale3_disparity_image/tag" + input: "truediv_24" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "add_21/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: 1.0 + } + } + } +} +node { + name: "add_21" + op: "Add" + input: "compute_loss/ResizeArea_6" + input: "add_21/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_25/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_25" + op: "RealDiv" + input: "add_21" + input: "truediv_25/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_21/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_21/Mul" + op: "Mul" + input: "truediv_25" + input: "convert_image_21/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_21" + op: "Cast" + input: "convert_image_21/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale3_target_image/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: "scale3_target_image" + } + } + } +} +node { + name: "scale3_target_image" + op: "ImageSummary" + input: "scale3_target_image/tag" + input: "convert_image_21" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_18/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "strided_slice_18/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_18/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_18" + op: "StridedSlice" + input: "compute_loss/ResizeArea_7" + input: "strided_slice_18/stack" + input: "strided_slice_18/stack_1" + input: "strided_slice_18/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "add_22/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: 1.0 + } + } + } +} +node { + name: "add_22" + op: "Add" + input: "strided_slice_18" + input: "add_22/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_26/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_26" + op: "RealDiv" + input: "add_22" + input: "truediv_26/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_22/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_22/Mul" + op: "Mul" + input: "truediv_26" + input: "convert_image_22/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_22" + op: "Cast" + input: "convert_image_22/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale3_source_image_0/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: "scale3_source_image_0" + } + } + } +} +node { + name: "scale3_source_image_0" + op: "ImageSummary" + input: "scale3_source_image_0/tag" + input: "convert_image_22" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_19/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "strided_slice_19/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_19/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_19" + op: "StridedSlice" + input: "compute_loss/concat_150" + input: "strided_slice_19/stack" + input: "strided_slice_19/stack_1" + input: "strided_slice_19/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "add_23/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: 1.0 + } + } + } +} +node { + name: "add_23" + op: "Add" + input: "strided_slice_19" + input: "add_23/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_27/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_27" + op: "RealDiv" + input: "add_23" + input: "truediv_27/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_23/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_23/Mul" + op: "Mul" + input: "truediv_27" + input: "convert_image_23/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_23" + op: "Cast" + input: "convert_image_23/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale3_projected_image_0/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: "scale3_projected_image_0" + } + } + } +} +node { + name: "scale3_projected_image_0" + op: "ImageSummary" + input: "scale3_projected_image_0/tag" + input: "convert_image_23" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_20/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "strided_slice_20/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_20/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_20" + op: "StridedSlice" + input: "compute_loss/concat_151" + input: "strided_slice_20/stack" + input: "strided_slice_20/stack_1" + input: "strided_slice_20/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "sub_6/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "sub_6" + op: "Sub" + input: "strided_slice_20" + input: "sub_6/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "clip_by_value_6/Minimum/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: 1.0 + } + } + } +} +node { + name: "clip_by_value_6/Minimum" + op: "Minimum" + input: "sub_6" + input: "clip_by_value_6/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "clip_by_value_6/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: -1.0 + } + } + } +} +node { + name: "clip_by_value_6" + op: "Maximum" + input: "clip_by_value_6/Minimum" + input: "clip_by_value_6/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "add_24/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: 1.0 + } + } + } +} +node { + name: "add_24" + op: "Add" + input: "clip_by_value_6" + input: "add_24/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_28/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_28" + op: "RealDiv" + input: "add_24" + input: "truediv_28/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_24/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_24/Mul" + op: "Mul" + input: "truediv_28" + input: "convert_image_24/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_24" + op: "Cast" + input: "convert_image_24/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale3_proj_error_0/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: "scale3_proj_error_0" + } + } + } +} +node { + name: "scale3_proj_error_0" + op: "ImageSummary" + input: "scale3_proj_error_0/tag" + input: "convert_image_24" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_21/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_21/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "strided_slice_21/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_21" + op: "StridedSlice" + input: "compute_loss/ResizeArea_7" + input: "strided_slice_21/stack" + input: "strided_slice_21/stack_1" + input: "strided_slice_21/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "add_25/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: 1.0 + } + } + } +} +node { + name: "add_25" + op: "Add" + input: "strided_slice_21" + input: "add_25/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_29/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_29" + op: "RealDiv" + input: "add_25" + input: "truediv_29/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_25/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_25/Mul" + op: "Mul" + input: "truediv_29" + input: "convert_image_25/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_25" + op: "Cast" + input: "convert_image_25/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale3_source_image_1/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: "scale3_source_image_1" + } + } + } +} +node { + name: "scale3_source_image_1" + op: "ImageSummary" + input: "scale3_source_image_1/tag" + input: "convert_image_25" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_22/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_22/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "strided_slice_22/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_22" + op: "StridedSlice" + input: "compute_loss/concat_150" + input: "strided_slice_22/stack" + input: "strided_slice_22/stack_1" + input: "strided_slice_22/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "add_26/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: 1.0 + } + } + } +} +node { + name: "add_26" + op: "Add" + input: "strided_slice_22" + input: "add_26/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_30/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_30" + op: "RealDiv" + input: "add_26" + input: "truediv_30/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_26/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_26/Mul" + op: "Mul" + input: "truediv_30" + input: "convert_image_26/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_26" + op: "Cast" + input: "convert_image_26/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale3_projected_image_1/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: "scale3_projected_image_1" + } + } + } +} +node { + name: "scale3_projected_image_1" + op: "ImageSummary" + input: "scale3_projected_image_1/tag" + input: "convert_image_26" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_23/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_23/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "strided_slice_23/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_23" + op: "StridedSlice" + input: "compute_loss/concat_151" + input: "strided_slice_23/stack" + input: "strided_slice_23/stack_1" + input: "strided_slice_23/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 7 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 7 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "sub_7/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "sub_7" + op: "Sub" + input: "strided_slice_23" + input: "sub_7/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "clip_by_value_7/Minimum/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: 1.0 + } + } + } +} +node { + name: "clip_by_value_7/Minimum" + op: "Minimum" + input: "sub_7" + input: "clip_by_value_7/Minimum/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "clip_by_value_7/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: -1.0 + } + } + } +} +node { + name: "clip_by_value_7" + op: "Maximum" + input: "clip_by_value_7/Minimum" + input: "clip_by_value_7/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "add_27/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: 1.0 + } + } + } +} +node { + name: "add_27" + op: "Add" + input: "clip_by_value_7" + input: "add_27/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "truediv_31/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 2.0 + } + } + } +} +node { + name: "truediv_31" + op: "RealDiv" + input: "add_27" + input: "truediv_31/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_27/Mul/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: 255.5 + } + } + } +} +node { + name: "convert_image_27/Mul" + op: "Mul" + input: "truediv_31" + input: "convert_image_27/Mul/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "convert_image_27" + op: "Cast" + input: "convert_image_27/Mul" + attr { + key: "DstT" + value { + type: DT_UINT8 + } + } + attr { + key: "SrcT" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 16 + } + dim { + size: 52 + } + dim { + size: 3 + } + } + } + } + } +} +node { + name: "scale3_proj_error_1/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: "scale3_proj_error_1" + } + } + } +} +node { + name: "scale3_proj_error_1" + op: "ImageSummary" + input: "scale3_proj_error_1/tag" + input: "convert_image_27" + attr { + key: "T" + value { + type: DT_UINT8 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "bad_color" + value { + tensor { + dtype: DT_UINT8 + tensor_shape { + dim { + size: 4 + } + } + int_val: 255 + int_val: 0 + int_val: 0 + int_val: 255 + } + } + } + attr { + key: "max_images" + value { + i: 3 + } + } +} +node { + name: "strided_slice_24/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "strided_slice_24/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_24/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_24" + op: "StridedSlice" + input: "pose_and_explainability_prediction/pose_exp_net/pose/mul" + input: "strided_slice_24/stack" + input: "strided_slice_24/stack_1" + input: "strided_slice_24/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 3 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 3 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 4 + } + } +} +node { + name: "tx/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: "tx" + } + } + } +} +node { + name: "tx" + op: "HistogramSummary" + input: "tx/tag" + input: "strided_slice_24" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "strided_slice_25/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_25/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "strided_slice_25/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_25" + op: "StridedSlice" + input: "pose_and_explainability_prediction/pose_exp_net/pose/mul" + input: "strided_slice_25/stack" + input: "strided_slice_25/stack_1" + input: "strided_slice_25/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 3 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 3 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 4 + } + } +} +node { + name: "ty/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: "ty" + } + } + } +} +node { + name: "ty" + op: "HistogramSummary" + input: "ty/tag" + input: "strided_slice_25" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "strided_slice_26/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\002\000\000\000" + } + } + } +} +node { + name: "strided_slice_26/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_26/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_26" + op: "StridedSlice" + input: "pose_and_explainability_prediction/pose_exp_net/pose/mul" + input: "strided_slice_26/stack" + input: "strided_slice_26/stack_1" + input: "strided_slice_26/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 3 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 3 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 4 + } + } +} +node { + name: "tz/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: "tz" + } + } + } +} +node { + name: "tz" + op: "HistogramSummary" + input: "tz/tag" + input: "strided_slice_26" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "strided_slice_27/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "strided_slice_27/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "strided_slice_27/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_27" + op: "StridedSlice" + input: "pose_and_explainability_prediction/pose_exp_net/pose/mul" + input: "strided_slice_27/stack" + input: "strided_slice_27/stack_1" + input: "strided_slice_27/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 3 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 3 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 4 + } + } +} +node { + name: "rx/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: "rx" + } + } + } +} +node { + name: "rx" + op: "HistogramSummary" + input: "rx/tag" + input: "strided_slice_27" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "strided_slice_28/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "strided_slice_28/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\005\000\000\000" + } + } + } +} +node { + name: "strided_slice_28/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_28" + op: "StridedSlice" + input: "pose_and_explainability_prediction/pose_exp_net/pose/mul" + input: "strided_slice_28/stack" + input: "strided_slice_28/stack_1" + input: "strided_slice_28/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 3 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 3 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 4 + } + } +} +node { + name: "ry/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: "ry" + } + } + } +} +node { + name: "ry" + op: "HistogramSummary" + input: "ry/tag" + input: "strided_slice_28" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "strided_slice_29/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\005\000\000\000" + } + } + } +} +node { + name: "strided_slice_29/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\006\000\000\000" + } + } + } +} +node { + name: "strided_slice_29/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "strided_slice_29" + op: "StridedSlice" + input: "pose_and_explainability_prediction/pose_exp_net/pose/mul" + input: "strided_slice_29/stack" + input: "strided_slice_29/stack_1" + input: "strided_slice_29/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + dim { + size: 2 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 3 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 3 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 4 + } + } +} +node { + name: "rz/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: "rz" + } + } + } +} +node { + name: "rz" + op: "HistogramSummary" + input: "rz/tag" + input: "strided_slice_29" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "parameter_count/Shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\007\000\000\000\007\000\000\000\003\000\000\000 \000\000\000" + } + } + } +} +node { + name: "parameter_count/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: "parameter_count/Prod" + op: "Prod" + input: "parameter_count/Shape" + input: "parameter_count/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: "parameter_count/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 32 + } + } + } +} +node { + name: "parameter_count/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: "parameter_count/Prod_1" + op: "Prod" + input: "parameter_count/Shape_1" + input: "parameter_count/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: "parameter_count/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\007\000\000\000\007\000\000\000 \000\000\000 \000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "parameter_count/Prod_2" + op: "Prod" + input: "parameter_count/Shape_2" + input: "parameter_count/Const_2" + 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: "parameter_count/Shape_3" + 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: 32 + } + } + } +} +node { + name: "parameter_count/Const_3" + 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: "parameter_count/Prod_3" + op: "Prod" + input: "parameter_count/Shape_3" + input: "parameter_count/Const_3" + 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: "parameter_count/Shape_4" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\005\000\000\000\005\000\000\000 \000\000\000@\000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_4" + 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: "parameter_count/Prod_4" + op: "Prod" + input: "parameter_count/Shape_4" + input: "parameter_count/Const_4" + 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: "parameter_count/Shape_5" + 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: 64 + } + } + } +} +node { + name: "parameter_count/Const_5" + 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: "parameter_count/Prod_5" + op: "Prod" + input: "parameter_count/Shape_5" + input: "parameter_count/Const_5" + 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: "parameter_count/Shape_6" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\005\000\000\000\005\000\000\000@\000\000\000@\000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_6" + 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: "parameter_count/Prod_6" + op: "Prod" + input: "parameter_count/Shape_6" + input: "parameter_count/Const_6" + 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: "parameter_count/Shape_7" + 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: 64 + } + } + } +} +node { + name: "parameter_count/Const_7" + 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: "parameter_count/Prod_7" + op: "Prod" + input: "parameter_count/Shape_7" + input: "parameter_count/Const_7" + 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: "parameter_count/Shape_8" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000@\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_8" + 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: "parameter_count/Prod_8" + op: "Prod" + input: "parameter_count/Shape_8" + input: "parameter_count/Const_8" + 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: "parameter_count/Shape_9" + 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: 128 + } + } + } +} +node { + name: "parameter_count/Const_9" + 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: "parameter_count/Prod_9" + op: "Prod" + input: "parameter_count/Shape_9" + input: "parameter_count/Const_9" + 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: "parameter_count/Shape_10" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_10" + 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: "parameter_count/Prod_10" + op: "Prod" + input: "parameter_count/Shape_10" + input: "parameter_count/Const_10" + 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: "parameter_count/Shape_11" + 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: 128 + } + } + } +} +node { + name: "parameter_count/Const_11" + 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: "parameter_count/Prod_11" + op: "Prod" + input: "parameter_count/Shape_11" + input: "parameter_count/Const_11" + 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: "parameter_count/Shape_12" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\000\001\000\000" + } + } + } +} +node { + name: "parameter_count/Const_12" + 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: "parameter_count/Prod_12" + op: "Prod" + input: "parameter_count/Shape_12" + input: "parameter_count/Const_12" + 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: "parameter_count/Shape_13" + 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: 256 + } + } + } +} +node { + name: "parameter_count/Const_13" + 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: "parameter_count/Prod_13" + op: "Prod" + input: "parameter_count/Shape_13" + input: "parameter_count/Const_13" + 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: "parameter_count/Shape_14" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\001\000\000" + } + } + } +} +node { + name: "parameter_count/Const_14" + 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: "parameter_count/Prod_14" + op: "Prod" + input: "parameter_count/Shape_14" + input: "parameter_count/Const_14" + 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: "parameter_count/Shape_15" + 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: 256 + } + } + } +} +node { + name: "parameter_count/Const_15" + 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: "parameter_count/Prod_15" + op: "Prod" + input: "parameter_count/Shape_15" + input: "parameter_count/Const_15" + 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: "parameter_count/Shape_16" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\002\000\000" + } + } + } +} +node { + name: "parameter_count/Const_16" + 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: "parameter_count/Prod_16" + op: "Prod" + input: "parameter_count/Shape_16" + input: "parameter_count/Const_16" + 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: "parameter_count/Shape_17" + 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: 512 + } + } + } +} +node { + name: "parameter_count/Const_17" + 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: "parameter_count/Prod_17" + op: "Prod" + input: "parameter_count/Shape_17" + input: "parameter_count/Const_17" + 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: "parameter_count/Shape_18" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "parameter_count/Const_18" + 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: "parameter_count/Prod_18" + op: "Prod" + input: "parameter_count/Shape_18" + input: "parameter_count/Const_18" + 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: "parameter_count/Shape_19" + 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: 512 + } + } + } +} +node { + name: "parameter_count/Const_19" + 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: "parameter_count/Prod_19" + op: "Prod" + input: "parameter_count/Shape_19" + input: "parameter_count/Const_19" + 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: "parameter_count/Shape_20" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "parameter_count/Const_20" + 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: "parameter_count/Prod_20" + op: "Prod" + input: "parameter_count/Shape_20" + input: "parameter_count/Const_20" + 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: "parameter_count/Shape_21" + 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: 512 + } + } + } +} +node { + name: "parameter_count/Const_21" + 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: "parameter_count/Prod_21" + op: "Prod" + input: "parameter_count/Shape_21" + input: "parameter_count/Const_21" + 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: "parameter_count/Shape_22" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "parameter_count/Const_22" + 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: "parameter_count/Prod_22" + op: "Prod" + input: "parameter_count/Shape_22" + input: "parameter_count/Const_22" + 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: "parameter_count/Shape_23" + 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: 512 + } + } + } +} +node { + name: "parameter_count/Const_23" + 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: "parameter_count/Prod_23" + op: "Prod" + input: "parameter_count/Shape_23" + input: "parameter_count/Const_23" + 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: "parameter_count/Shape_24" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "parameter_count/Const_24" + 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: "parameter_count/Prod_24" + op: "Prod" + input: "parameter_count/Shape_24" + input: "parameter_count/Const_24" + 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: "parameter_count/Shape_25" + 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: 512 + } + } + } +} +node { + name: "parameter_count/Const_25" + 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: "parameter_count/Prod_25" + op: "Prod" + input: "parameter_count/Shape_25" + input: "parameter_count/Const_25" + 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: "parameter_count/Shape_26" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "parameter_count/Const_26" + 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: "parameter_count/Prod_26" + op: "Prod" + input: "parameter_count/Shape_26" + input: "parameter_count/Const_26" + 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: "parameter_count/Shape_27" + 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: 512 + } + } + } +} +node { + name: "parameter_count/Const_27" + 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: "parameter_count/Prod_27" + op: "Prod" + input: "parameter_count/Shape_27" + input: "parameter_count/Const_27" + 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: "parameter_count/Shape_28" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "parameter_count/Const_28" + 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: "parameter_count/Prod_28" + op: "Prod" + input: "parameter_count/Shape_28" + input: "parameter_count/Const_28" + 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: "parameter_count/Shape_29" + 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: 512 + } + } + } +} +node { + name: "parameter_count/Const_29" + 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: "parameter_count/Prod_29" + op: "Prod" + input: "parameter_count/Shape_29" + input: "parameter_count/Const_29" + 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: "parameter_count/Shape_30" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\004\000\000\000\002\000\000" + } + } + } +} +node { + name: "parameter_count/Const_30" + 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: "parameter_count/Prod_30" + op: "Prod" + input: "parameter_count/Shape_30" + input: "parameter_count/Const_30" + 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: "parameter_count/Shape_31" + 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: 512 + } + } + } +} +node { + name: "parameter_count/Const_31" + 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: "parameter_count/Prod_31" + op: "Prod" + input: "parameter_count/Shape_31" + input: "parameter_count/Const_31" + 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: "parameter_count/Shape_32" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\002\000\000" + } + } + } +} +node { + name: "parameter_count/Const_32" + 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: "parameter_count/Prod_32" + op: "Prod" + input: "parameter_count/Shape_32" + input: "parameter_count/Const_32" + 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: "parameter_count/Shape_33" + 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: 512 + } + } + } +} +node { + name: "parameter_count/Const_33" + 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: "parameter_count/Prod_33" + op: "Prod" + input: "parameter_count/Shape_33" + input: "parameter_count/Const_33" + 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: "parameter_count/Shape_34" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\004\000\000\000\002\000\000" + } + } + } +} +node { + name: "parameter_count/Const_34" + 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: "parameter_count/Prod_34" + op: "Prod" + input: "parameter_count/Shape_34" + input: "parameter_count/Const_34" + 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: "parameter_count/Shape_35" + 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: 512 + } + } + } +} +node { + name: "parameter_count/Const_35" + 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: "parameter_count/Prod_35" + op: "Prod" + input: "parameter_count/Shape_35" + input: "parameter_count/Const_35" + 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: "parameter_count/Shape_36" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\002\000\000" + } + } + } +} +node { + name: "parameter_count/Const_36" + 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: "parameter_count/Prod_36" + op: "Prod" + input: "parameter_count/Shape_36" + input: "parameter_count/Const_36" + 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: "parameter_count/Shape_37" + 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: 256 + } + } + } +} +node { + name: "parameter_count/Const_37" + 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: "parameter_count/Prod_37" + op: "Prod" + input: "parameter_count/Shape_37" + input: "parameter_count/Const_37" + 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: "parameter_count/Shape_38" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\002\000\000\000\001\000\000" + } + } + } +} +node { + name: "parameter_count/Const_38" + 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: "parameter_count/Prod_38" + op: "Prod" + input: "parameter_count/Shape_38" + input: "parameter_count/Const_38" + 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: "parameter_count/Shape_39" + 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: 256 + } + } + } +} +node { + name: "parameter_count/Const_39" + 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: "parameter_count/Prod_39" + op: "Prod" + input: "parameter_count/Shape_39" + input: "parameter_count/Const_39" + 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: "parameter_count/Shape_40" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\000\001\000\000" + } + } + } +} +node { + name: "parameter_count/Const_40" + 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: "parameter_count/Prod_40" + op: "Prod" + input: "parameter_count/Shape_40" + input: "parameter_count/Const_40" + 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: "parameter_count/Shape_41" + 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: 128 + } + } + } +} +node { + name: "parameter_count/Const_41" + 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: "parameter_count/Prod_41" + op: "Prod" + input: "parameter_count/Shape_41" + input: "parameter_count/Const_41" + 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: "parameter_count/Shape_42" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\200\000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_42" + 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: "parameter_count/Prod_42" + op: "Prod" + input: "parameter_count/Shape_42" + input: "parameter_count/Const_42" + 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: "parameter_count/Shape_43" + 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: 128 + } + } + } +} +node { + name: "parameter_count/Const_43" + 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: "parameter_count/Prod_43" + op: "Prod" + input: "parameter_count/Shape_43" + input: "parameter_count/Const_43" + 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: "parameter_count/Shape_44" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_44" + 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: "parameter_count/Prod_44" + op: "Prod" + input: "parameter_count/Shape_44" + input: "parameter_count/Const_44" + 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: "parameter_count/Shape_45" + 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: "parameter_count/Const_45" + 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: "parameter_count/Prod_45" + op: "Prod" + input: "parameter_count/Shape_45" + input: "parameter_count/Const_45" + 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: "parameter_count/Shape_46" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000@\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_46" + 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: "parameter_count/Prod_46" + op: "Prod" + input: "parameter_count/Shape_46" + input: "parameter_count/Const_46" + 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: "parameter_count/Shape_47" + 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: 64 + } + } + } +} +node { + name: "parameter_count/Const_47" + 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: "parameter_count/Prod_47" + op: "Prod" + input: "parameter_count/Shape_47" + input: "parameter_count/Const_47" + 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: "parameter_count/Shape_48" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\201\000\000\000@\000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_48" + 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: "parameter_count/Prod_48" + op: "Prod" + input: "parameter_count/Shape_48" + input: "parameter_count/Const_48" + 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: "parameter_count/Shape_49" + 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: 64 + } + } + } +} +node { + name: "parameter_count/Const_49" + 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: "parameter_count/Prod_49" + op: "Prod" + input: "parameter_count/Shape_49" + input: "parameter_count/Const_49" + 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: "parameter_count/Shape_50" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000@\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_50" + 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: "parameter_count/Prod_50" + op: "Prod" + input: "parameter_count/Shape_50" + input: "parameter_count/Const_50" + 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: "parameter_count/Shape_51" + 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: "parameter_count/Const_51" + 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: "parameter_count/Prod_51" + op: "Prod" + input: "parameter_count/Shape_51" + input: "parameter_count/Const_51" + 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: "parameter_count/Shape_52" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000 \000\000\000@\000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_52" + 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: "parameter_count/Prod_52" + op: "Prod" + input: "parameter_count/Shape_52" + input: "parameter_count/Const_52" + 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: "parameter_count/Shape_53" + 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: 32 + } + } + } +} +node { + name: "parameter_count/Const_53" + 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: "parameter_count/Prod_53" + op: "Prod" + input: "parameter_count/Shape_53" + input: "parameter_count/Const_53" + 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: "parameter_count/Shape_54" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000A\000\000\000 \000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_54" + 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: "parameter_count/Prod_54" + op: "Prod" + input: "parameter_count/Shape_54" + input: "parameter_count/Const_54" + 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: "parameter_count/Shape_55" + 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: 32 + } + } + } +} +node { + name: "parameter_count/Const_55" + 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: "parameter_count/Prod_55" + op: "Prod" + input: "parameter_count/Shape_55" + input: "parameter_count/Const_55" + 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: "parameter_count/Shape_56" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000 \000\000\000\001\000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_56" + 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: "parameter_count/Prod_56" + op: "Prod" + input: "parameter_count/Shape_56" + input: "parameter_count/Const_56" + 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: "parameter_count/Shape_57" + 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: "parameter_count/Const_57" + 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: "parameter_count/Prod_57" + op: "Prod" + input: "parameter_count/Shape_57" + input: "parameter_count/Const_57" + 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: "parameter_count/Shape_58" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\020\000\000\000 \000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_58" + 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: "parameter_count/Prod_58" + op: "Prod" + input: "parameter_count/Shape_58" + input: "parameter_count/Const_58" + 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: "parameter_count/Shape_59" + 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: 16 + } + } + } +} +node { + name: "parameter_count/Const_59" + 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: "parameter_count/Prod_59" + op: "Prod" + input: "parameter_count/Shape_59" + input: "parameter_count/Const_59" + 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: "parameter_count/Shape_60" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\021\000\000\000\020\000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_60" + 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: "parameter_count/Prod_60" + op: "Prod" + input: "parameter_count/Shape_60" + input: "parameter_count/Const_60" + 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: "parameter_count/Shape_61" + 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: 16 + } + } + } +} +node { + name: "parameter_count/Const_61" + 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: "parameter_count/Prod_61" + op: "Prod" + input: "parameter_count/Shape_61" + input: "parameter_count/Const_61" + 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: "parameter_count/Shape_62" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\020\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_62" + 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: "parameter_count/Prod_62" + op: "Prod" + input: "parameter_count/Shape_62" + input: "parameter_count/Const_62" + 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: "parameter_count/Shape_63" + 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: "parameter_count/Const_63" + 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: "parameter_count/Prod_63" + op: "Prod" + input: "parameter_count/Shape_63" + input: "parameter_count/Const_63" + 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: "parameter_count/Shape_64" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\007\000\000\000\007\000\000\000\t\000\000\000\020\000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_64" + 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: "parameter_count/Prod_64" + op: "Prod" + input: "parameter_count/Shape_64" + input: "parameter_count/Const_64" + 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: "parameter_count/Shape_65" + 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: 16 + } + } + } +} +node { + name: "parameter_count/Const_65" + 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: "parameter_count/Prod_65" + op: "Prod" + input: "parameter_count/Shape_65" + input: "parameter_count/Const_65" + 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: "parameter_count/Shape_66" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\005\000\000\000\005\000\000\000\020\000\000\000 \000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_66" + 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: "parameter_count/Prod_66" + op: "Prod" + input: "parameter_count/Shape_66" + input: "parameter_count/Const_66" + 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: "parameter_count/Shape_67" + 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: 32 + } + } + } +} +node { + name: "parameter_count/Const_67" + 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: "parameter_count/Prod_67" + op: "Prod" + input: "parameter_count/Shape_67" + input: "parameter_count/Const_67" + 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: "parameter_count/Shape_68" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000 \000\000\000@\000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_68" + 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: "parameter_count/Prod_68" + op: "Prod" + input: "parameter_count/Shape_68" + input: "parameter_count/Const_68" + 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: "parameter_count/Shape_69" + 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: 64 + } + } + } +} +node { + name: "parameter_count/Const_69" + 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: "parameter_count/Prod_69" + op: "Prod" + input: "parameter_count/Shape_69" + input: "parameter_count/Const_69" + 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: "parameter_count/Shape_70" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000@\000\000\000\200\000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_70" + 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: "parameter_count/Prod_70" + op: "Prod" + input: "parameter_count/Shape_70" + input: "parameter_count/Const_70" + 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: "parameter_count/Shape_71" + 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: 128 + } + } + } +} +node { + name: "parameter_count/Const_71" + 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: "parameter_count/Prod_71" + op: "Prod" + input: "parameter_count/Shape_71" + input: "parameter_count/Const_71" + 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: "parameter_count/Shape_72" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\200\000\000\000\000\001\000\000" + } + } + } +} +node { + name: "parameter_count/Const_72" + 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: "parameter_count/Prod_72" + op: "Prod" + input: "parameter_count/Shape_72" + input: "parameter_count/Const_72" + 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: "parameter_count/Shape_73" + 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: 256 + } + } + } +} +node { + name: "parameter_count/Const_73" + 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: "parameter_count/Prod_73" + op: "Prod" + input: "parameter_count/Shape_73" + input: "parameter_count/Const_73" + 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: "parameter_count/Shape_74" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\001\000\000" + } + } + } +} +node { + name: "parameter_count/Const_74" + 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: "parameter_count/Prod_74" + op: "Prod" + input: "parameter_count/Shape_74" + input: "parameter_count/Const_74" + 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: "parameter_count/Shape_75" + 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: 256 + } + } + } +} +node { + name: "parameter_count/Const_75" + 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: "parameter_count/Prod_75" + op: "Prod" + input: "parameter_count/Shape_75" + input: "parameter_count/Const_75" + 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: "parameter_count/Shape_76" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\003\000\000\000\003\000\000\000\000\001\000\000\000\001\000\000" + } + } + } +} +node { + name: "parameter_count/Const_76" + 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: "parameter_count/Prod_76" + op: "Prod" + input: "parameter_count/Shape_76" + input: "parameter_count/Const_76" + 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: "parameter_count/Shape_77" + 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: 256 + } + } + } +} +node { + name: "parameter_count/Const_77" + 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: "parameter_count/Prod_77" + op: "Prod" + input: "parameter_count/Shape_77" + input: "parameter_count/Const_77" + 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: "parameter_count/Shape_78" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\001\000\000\000\001\000\000\000\000\001\000\000\014\000\000\000" + } + } + } +} +node { + name: "parameter_count/Const_78" + 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: "parameter_count/Prod_78" + op: "Prod" + input: "parameter_count/Shape_78" + input: "parameter_count/Const_78" + 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: "parameter_count/Shape_79" + 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: 12 + } + } + } +} +node { + name: "parameter_count/Const_79" + 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: "parameter_count/Prod_79" + op: "Prod" + input: "parameter_count/Shape_79" + input: "parameter_count/Const_79" + 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: "parameter_count/Rank/packed" + op: "Pack" + input: "parameter_count/Prod" + input: "parameter_count/Prod_1" + input: "parameter_count/Prod_2" + input: "parameter_count/Prod_3" + input: "parameter_count/Prod_4" + input: "parameter_count/Prod_5" + input: "parameter_count/Prod_6" + input: "parameter_count/Prod_7" + input: "parameter_count/Prod_8" + input: "parameter_count/Prod_9" + input: "parameter_count/Prod_10" + input: "parameter_count/Prod_11" + input: "parameter_count/Prod_12" + input: "parameter_count/Prod_13" + input: "parameter_count/Prod_14" + input: "parameter_count/Prod_15" + input: "parameter_count/Prod_16" + input: "parameter_count/Prod_17" + input: "parameter_count/Prod_18" + input: "parameter_count/Prod_19" + input: "parameter_count/Prod_20" + input: "parameter_count/Prod_21" + input: "parameter_count/Prod_22" + input: "parameter_count/Prod_23" + input: "parameter_count/Prod_24" + input: "parameter_count/Prod_25" + input: "parameter_count/Prod_26" + input: "parameter_count/Prod_27" + input: "parameter_count/Prod_28" + input: "parameter_count/Prod_29" + input: "parameter_count/Prod_30" + input: "parameter_count/Prod_31" + input: "parameter_count/Prod_32" + input: "parameter_count/Prod_33" + input: "parameter_count/Prod_34" + input: "parameter_count/Prod_35" + input: "parameter_count/Prod_36" + input: "parameter_count/Prod_37" + input: "parameter_count/Prod_38" + input: "parameter_count/Prod_39" + input: "parameter_count/Prod_40" + input: "parameter_count/Prod_41" + input: "parameter_count/Prod_42" + input: "parameter_count/Prod_43" + input: "parameter_count/Prod_44" + input: "parameter_count/Prod_45" + input: "parameter_count/Prod_46" + input: "parameter_count/Prod_47" + input: "parameter_count/Prod_48" + input: "parameter_count/Prod_49" + input: "parameter_count/Prod_50" + input: "parameter_count/Prod_51" + input: "parameter_count/Prod_52" + input: "parameter_count/Prod_53" + input: "parameter_count/Prod_54" + input: "parameter_count/Prod_55" + input: "parameter_count/Prod_56" + input: "parameter_count/Prod_57" + input: "parameter_count/Prod_58" + input: "parameter_count/Prod_59" + input: "parameter_count/Prod_60" + input: "parameter_count/Prod_61" + input: "parameter_count/Prod_62" + input: "parameter_count/Prod_63" + input: "parameter_count/Prod_64" + input: "parameter_count/Prod_65" + input: "parameter_count/Prod_66" + input: "parameter_count/Prod_67" + input: "parameter_count/Prod_68" + input: "parameter_count/Prod_69" + input: "parameter_count/Prod_70" + input: "parameter_count/Prod_71" + input: "parameter_count/Prod_72" + input: "parameter_count/Prod_73" + input: "parameter_count/Prod_74" + input: "parameter_count/Prod_75" + input: "parameter_count/Prod_76" + input: "parameter_count/Prod_77" + input: "parameter_count/Prod_78" + input: "parameter_count/Prod_79" + attr { + key: "N" + value { + i: 80 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 80 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "parameter_count/Rank" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "parameter_count/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: "parameter_count/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: "parameter_count/range" + op: "Range" + input: "parameter_count/range/start" + input: "parameter_count/Rank" + input: "parameter_count/range/delta" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "parameter_count/Sum/input" + op: "Pack" + input: "parameter_count/Prod" + input: "parameter_count/Prod_1" + input: "parameter_count/Prod_2" + input: "parameter_count/Prod_3" + input: "parameter_count/Prod_4" + input: "parameter_count/Prod_5" + input: "parameter_count/Prod_6" + input: "parameter_count/Prod_7" + input: "parameter_count/Prod_8" + input: "parameter_count/Prod_9" + input: "parameter_count/Prod_10" + input: "parameter_count/Prod_11" + input: "parameter_count/Prod_12" + input: "parameter_count/Prod_13" + input: "parameter_count/Prod_14" + input: "parameter_count/Prod_15" + input: "parameter_count/Prod_16" + input: "parameter_count/Prod_17" + input: "parameter_count/Prod_18" + input: "parameter_count/Prod_19" + input: "parameter_count/Prod_20" + input: "parameter_count/Prod_21" + input: "parameter_count/Prod_22" + input: "parameter_count/Prod_23" + input: "parameter_count/Prod_24" + input: "parameter_count/Prod_25" + input: "parameter_count/Prod_26" + input: "parameter_count/Prod_27" + input: "parameter_count/Prod_28" + input: "parameter_count/Prod_29" + input: "parameter_count/Prod_30" + input: "parameter_count/Prod_31" + input: "parameter_count/Prod_32" + input: "parameter_count/Prod_33" + input: "parameter_count/Prod_34" + input: "parameter_count/Prod_35" + input: "parameter_count/Prod_36" + input: "parameter_count/Prod_37" + input: "parameter_count/Prod_38" + input: "parameter_count/Prod_39" + input: "parameter_count/Prod_40" + input: "parameter_count/Prod_41" + input: "parameter_count/Prod_42" + input: "parameter_count/Prod_43" + input: "parameter_count/Prod_44" + input: "parameter_count/Prod_45" + input: "parameter_count/Prod_46" + input: "parameter_count/Prod_47" + input: "parameter_count/Prod_48" + input: "parameter_count/Prod_49" + input: "parameter_count/Prod_50" + input: "parameter_count/Prod_51" + input: "parameter_count/Prod_52" + input: "parameter_count/Prod_53" + input: "parameter_count/Prod_54" + input: "parameter_count/Prod_55" + input: "parameter_count/Prod_56" + input: "parameter_count/Prod_57" + input: "parameter_count/Prod_58" + input: "parameter_count/Prod_59" + input: "parameter_count/Prod_60" + input: "parameter_count/Prod_61" + input: "parameter_count/Prod_62" + input: "parameter_count/Prod_63" + input: "parameter_count/Prod_64" + input: "parameter_count/Prod_65" + input: "parameter_count/Prod_66" + input: "parameter_count/Prod_67" + input: "parameter_count/Prod_68" + input: "parameter_count/Prod_69" + input: "parameter_count/Prod_70" + input: "parameter_count/Prod_71" + input: "parameter_count/Prod_72" + input: "parameter_count/Prod_73" + input: "parameter_count/Prod_74" + input: "parameter_count/Prod_75" + input: "parameter_count/Prod_76" + input: "parameter_count/Prod_77" + input: "parameter_count/Prod_78" + input: "parameter_count/Prod_79" + attr { + key: "N" + value { + i: 80 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 80 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "parameter_count/Sum" + op: "Sum" + input: "parameter_count/Sum/input" + input: "parameter_count/range" + 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: "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/SaveV2/tensor_names" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 81 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 81 + } + } + string_val: "depth_net/cnv1/biases" + string_val: "depth_net/cnv1/weights" + string_val: "depth_net/cnv1b/biases" + string_val: "depth_net/cnv1b/weights" + string_val: "depth_net/cnv2/biases" + string_val: "depth_net/cnv2/weights" + string_val: "depth_net/cnv2b/biases" + string_val: "depth_net/cnv2b/weights" + string_val: "depth_net/cnv3/biases" + string_val: "depth_net/cnv3/weights" + string_val: "depth_net/cnv3b/biases" + string_val: "depth_net/cnv3b/weights" + string_val: "depth_net/cnv4/biases" + string_val: "depth_net/cnv4/weights" + string_val: "depth_net/cnv4b/biases" + string_val: "depth_net/cnv4b/weights" + string_val: "depth_net/cnv5/biases" + string_val: "depth_net/cnv5/weights" + string_val: "depth_net/cnv5b/biases" + string_val: "depth_net/cnv5b/weights" + string_val: "depth_net/cnv6/biases" + string_val: "depth_net/cnv6/weights" + string_val: "depth_net/cnv6b/biases" + string_val: "depth_net/cnv6b/weights" + string_val: "depth_net/cnv7/biases" + string_val: "depth_net/cnv7/weights" + string_val: "depth_net/cnv7b/biases" + string_val: "depth_net/cnv7b/weights" + string_val: "depth_net/disp1/biases" + string_val: "depth_net/disp1/weights" + string_val: "depth_net/disp2/biases" + string_val: "depth_net/disp2/weights" + string_val: "depth_net/disp3/biases" + string_val: "depth_net/disp3/weights" + string_val: "depth_net/disp4/biases" + string_val: "depth_net/disp4/weights" + string_val: "depth_net/icnv1/biases" + string_val: "depth_net/icnv1/weights" + string_val: "depth_net/icnv2/biases" + string_val: "depth_net/icnv2/weights" + string_val: "depth_net/icnv3/biases" + string_val: "depth_net/icnv3/weights" + string_val: "depth_net/icnv4/biases" + string_val: "depth_net/icnv4/weights" + string_val: "depth_net/icnv5/biases" + string_val: "depth_net/icnv5/weights" + string_val: "depth_net/icnv6/biases" + string_val: "depth_net/icnv6/weights" + string_val: "depth_net/icnv7/biases" + string_val: "depth_net/icnv7/weights" + string_val: "depth_net/upcnv1/biases" + string_val: "depth_net/upcnv1/weights" + string_val: "depth_net/upcnv2/biases" + string_val: "depth_net/upcnv2/weights" + string_val: "depth_net/upcnv3/biases" + string_val: "depth_net/upcnv3/weights" + string_val: "depth_net/upcnv4/biases" + string_val: "depth_net/upcnv4/weights" + string_val: "depth_net/upcnv5/biases" + string_val: "depth_net/upcnv5/weights" + string_val: "depth_net/upcnv6/biases" + string_val: "depth_net/upcnv6/weights" + string_val: "depth_net/upcnv7/biases" + string_val: "depth_net/upcnv7/weights" + string_val: "pose_exp_net/cnv1/biases" + string_val: "pose_exp_net/cnv1/weights" + string_val: "pose_exp_net/cnv2/biases" + string_val: "pose_exp_net/cnv2/weights" + string_val: "pose_exp_net/cnv3/biases" + string_val: "pose_exp_net/cnv3/weights" + string_val: "pose_exp_net/cnv4/biases" + string_val: "pose_exp_net/cnv4/weights" + string_val: "pose_exp_net/cnv5/biases" + string_val: "pose_exp_net/cnv5/weights" + string_val: "pose_exp_net/pose/cnv6/biases" + string_val: "pose_exp_net/pose/cnv6/weights" + string_val: "pose_exp_net/pose/cnv7/biases" + string_val: "pose_exp_net/pose/cnv7/weights" + string_val: "pose_exp_net/pose/pred/biases" + string_val: "pose_exp_net/pose/pred/weights" + string_val: "train_op/global_step" + } + } + } +} +node { + name: "save/SaveV2/shape_and_slices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 81 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 81 + } + } + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + } + } + } +} +node { + name: "save/SaveV2" + op: "SaveV2" + input: "save/Const" + input: "save/SaveV2/tensor_names" + input: "save/SaveV2/shape_and_slices" + input: "depth_net/cnv1/biases" + input: "depth_net/cnv1/weights" + input: "depth_net/cnv1b/biases" + input: "depth_net/cnv1b/weights" + input: "depth_net/cnv2/biases" + input: "depth_net/cnv2/weights" + input: "depth_net/cnv2b/biases" + input: "depth_net/cnv2b/weights" + input: "depth_net/cnv3/biases" + input: "depth_net/cnv3/weights" + input: "depth_net/cnv3b/biases" + input: "depth_net/cnv3b/weights" + input: "depth_net/cnv4/biases" + input: "depth_net/cnv4/weights" + input: "depth_net/cnv4b/biases" + input: "depth_net/cnv4b/weights" + input: "depth_net/cnv5/biases" + input: "depth_net/cnv5/weights" + input: "depth_net/cnv5b/biases" + input: "depth_net/cnv5b/weights" + input: "depth_net/cnv6/biases" + input: "depth_net/cnv6/weights" + input: "depth_net/cnv6b/biases" + input: "depth_net/cnv6b/weights" + input: "depth_net/cnv7/biases" + input: "depth_net/cnv7/weights" + input: "depth_net/cnv7b/biases" + input: "depth_net/cnv7b/weights" + input: "depth_net/disp1/biases" + input: "depth_net/disp1/weights" + input: "depth_net/disp2/biases" + input: "depth_net/disp2/weights" + input: "depth_net/disp3/biases" + input: "depth_net/disp3/weights" + input: "depth_net/disp4/biases" + input: "depth_net/disp4/weights" + input: "depth_net/icnv1/biases" + input: "depth_net/icnv1/weights" + input: "depth_net/icnv2/biases" + input: "depth_net/icnv2/weights" + input: "depth_net/icnv3/biases" + input: "depth_net/icnv3/weights" + input: "depth_net/icnv4/biases" + input: "depth_net/icnv4/weights" + input: "depth_net/icnv5/biases" + input: "depth_net/icnv5/weights" + input: "depth_net/icnv6/biases" + input: "depth_net/icnv6/weights" + input: "depth_net/icnv7/biases" + input: "depth_net/icnv7/weights" + input: "depth_net/upcnv1/biases" + input: "depth_net/upcnv1/weights" + input: "depth_net/upcnv2/biases" + input: "depth_net/upcnv2/weights" + input: "depth_net/upcnv3/biases" + input: "depth_net/upcnv3/weights" + input: "depth_net/upcnv4/biases" + input: "depth_net/upcnv4/weights" + input: "depth_net/upcnv5/biases" + input: "depth_net/upcnv5/weights" + input: "depth_net/upcnv6/biases" + input: "depth_net/upcnv6/weights" + input: "depth_net/upcnv7/biases" + input: "depth_net/upcnv7/weights" + input: "pose_exp_net/cnv1/biases" + input: "pose_exp_net/cnv1/weights" + input: "pose_exp_net/cnv2/biases" + input: "pose_exp_net/cnv2/weights" + input: "pose_exp_net/cnv3/biases" + input: "pose_exp_net/cnv3/weights" + input: "pose_exp_net/cnv4/biases" + input: "pose_exp_net/cnv4/weights" + input: "pose_exp_net/cnv5/biases" + input: "pose_exp_net/cnv5/weights" + input: "pose_exp_net/pose/cnv6/biases" + input: "pose_exp_net/pose/cnv6/weights" + input: "pose_exp_net/pose/cnv7/biases" + input: "pose_exp_net/pose/cnv7/weights" + input: "pose_exp_net/pose/pred/biases" + input: "pose_exp_net/pose/pred/weights" + input: "train_op/global_step" + attr { + key: "dtypes" + value { + list { + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_INT32 + } + } + } +} +node { + name: "save/control_dependency" + op: "Identity" + input: "save/Const" + input: "^save/SaveV2" + attr { + key: "T" + value { + type: DT_STRING + } + } + attr { + key: "_class" + value { + list { + s: "loc:@save/Const" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "save/RestoreV2/tensor_names" + op: "Const" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 81 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 81 + } + } + string_val: "depth_net/cnv1/biases" + string_val: "depth_net/cnv1/weights" + string_val: "depth_net/cnv1b/biases" + string_val: "depth_net/cnv1b/weights" + string_val: "depth_net/cnv2/biases" + string_val: "depth_net/cnv2/weights" + string_val: "depth_net/cnv2b/biases" + string_val: "depth_net/cnv2b/weights" + string_val: "depth_net/cnv3/biases" + string_val: "depth_net/cnv3/weights" + string_val: "depth_net/cnv3b/biases" + string_val: "depth_net/cnv3b/weights" + string_val: "depth_net/cnv4/biases" + string_val: "depth_net/cnv4/weights" + string_val: "depth_net/cnv4b/biases" + string_val: "depth_net/cnv4b/weights" + string_val: "depth_net/cnv5/biases" + string_val: "depth_net/cnv5/weights" + string_val: "depth_net/cnv5b/biases" + string_val: "depth_net/cnv5b/weights" + string_val: "depth_net/cnv6/biases" + string_val: "depth_net/cnv6/weights" + string_val: "depth_net/cnv6b/biases" + string_val: "depth_net/cnv6b/weights" + string_val: "depth_net/cnv7/biases" + string_val: "depth_net/cnv7/weights" + string_val: "depth_net/cnv7b/biases" + string_val: "depth_net/cnv7b/weights" + string_val: "depth_net/disp1/biases" + string_val: "depth_net/disp1/weights" + string_val: "depth_net/disp2/biases" + string_val: "depth_net/disp2/weights" + string_val: "depth_net/disp3/biases" + string_val: "depth_net/disp3/weights" + string_val: "depth_net/disp4/biases" + string_val: "depth_net/disp4/weights" + string_val: "depth_net/icnv1/biases" + string_val: "depth_net/icnv1/weights" + string_val: "depth_net/icnv2/biases" + string_val: "depth_net/icnv2/weights" + string_val: "depth_net/icnv3/biases" + string_val: "depth_net/icnv3/weights" + string_val: "depth_net/icnv4/biases" + string_val: "depth_net/icnv4/weights" + string_val: "depth_net/icnv5/biases" + string_val: "depth_net/icnv5/weights" + string_val: "depth_net/icnv6/biases" + string_val: "depth_net/icnv6/weights" + string_val: "depth_net/icnv7/biases" + string_val: "depth_net/icnv7/weights" + string_val: "depth_net/upcnv1/biases" + string_val: "depth_net/upcnv1/weights" + string_val: "depth_net/upcnv2/biases" + string_val: "depth_net/upcnv2/weights" + string_val: "depth_net/upcnv3/biases" + string_val: "depth_net/upcnv3/weights" + string_val: "depth_net/upcnv4/biases" + string_val: "depth_net/upcnv4/weights" + string_val: "depth_net/upcnv5/biases" + string_val: "depth_net/upcnv5/weights" + string_val: "depth_net/upcnv6/biases" + string_val: "depth_net/upcnv6/weights" + string_val: "depth_net/upcnv7/biases" + string_val: "depth_net/upcnv7/weights" + string_val: "pose_exp_net/cnv1/biases" + string_val: "pose_exp_net/cnv1/weights" + string_val: "pose_exp_net/cnv2/biases" + string_val: "pose_exp_net/cnv2/weights" + string_val: "pose_exp_net/cnv3/biases" + string_val: "pose_exp_net/cnv3/weights" + string_val: "pose_exp_net/cnv4/biases" + string_val: "pose_exp_net/cnv4/weights" + string_val: "pose_exp_net/cnv5/biases" + string_val: "pose_exp_net/cnv5/weights" + string_val: "pose_exp_net/pose/cnv6/biases" + string_val: "pose_exp_net/pose/cnv6/weights" + string_val: "pose_exp_net/pose/cnv7/biases" + string_val: "pose_exp_net/pose/cnv7/weights" + string_val: "pose_exp_net/pose/pred/biases" + string_val: "pose_exp_net/pose/pred/weights" + string_val: "train_op/global_step" + } + } + } +} +node { + name: "save/RestoreV2/shape_and_slices" + op: "Const" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 81 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 81 + } + } + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + string_val: "" + } + } + } +} +node { + name: "save/RestoreV2" + op: "RestoreV2" + input: "save/Const" + input: "save/RestoreV2/tensor_names" + input: "save/RestoreV2/shape_and_slices" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + shape { + unknown_rank: true + } + } + } + } + attr { + key: "dtypes" + value { + list { + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_FLOAT + type: DT_INT32 + } + } + } +} +node { + name: "save/Assign" + op: "Assign" + input: "depth_net/cnv1/biases" + input: "save/RestoreV2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_1" + op: "Assign" + input: "depth_net/cnv1/weights" + input: "save/RestoreV2:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 3 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_2" + op: "Assign" + input: "depth_net/cnv1b/biases" + input: "save/RestoreV2:2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_3" + op: "Assign" + input: "depth_net/cnv1b/weights" + input: "save/RestoreV2:3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 32 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_4" + op: "Assign" + input: "depth_net/cnv2/biases" + input: "save/RestoreV2:4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_5" + op: "Assign" + input: "depth_net/cnv2/weights" + input: "save/RestoreV2:5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_6" + op: "Assign" + input: "depth_net/cnv2b/biases" + input: "save/RestoreV2:6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_7" + op: "Assign" + input: "depth_net/cnv2b/weights" + input: "save/RestoreV2:7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 64 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_8" + op: "Assign" + input: "depth_net/cnv3/biases" + input: "save/RestoreV2:8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_9" + op: "Assign" + input: "depth_net/cnv3/weights" + input: "save/RestoreV2:9" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_10" + op: "Assign" + input: "depth_net/cnv3b/biases" + input: "save/RestoreV2:10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_11" + op: "Assign" + input: "depth_net/cnv3b/weights" + input: "save/RestoreV2:11" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_12" + op: "Assign" + input: "depth_net/cnv4/biases" + input: "save/RestoreV2:12" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_13" + op: "Assign" + input: "depth_net/cnv4/weights" + input: "save/RestoreV2:13" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_14" + op: "Assign" + input: "depth_net/cnv4b/biases" + input: "save/RestoreV2:14" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_15" + op: "Assign" + input: "depth_net/cnv4b/weights" + input: "save/RestoreV2:15" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_16" + op: "Assign" + input: "depth_net/cnv5/biases" + input: "save/RestoreV2:16" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_17" + op: "Assign" + input: "depth_net/cnv5/weights" + input: "save/RestoreV2:17" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_18" + op: "Assign" + input: "depth_net/cnv5b/biases" + input: "save/RestoreV2:18" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_19" + op: "Assign" + input: "depth_net/cnv5b/weights" + input: "save/RestoreV2:19" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_20" + op: "Assign" + input: "depth_net/cnv6/biases" + input: "save/RestoreV2:20" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_21" + op: "Assign" + input: "depth_net/cnv6/weights" + input: "save/RestoreV2:21" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_22" + op: "Assign" + input: "depth_net/cnv6b/biases" + input: "save/RestoreV2:22" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_23" + op: "Assign" + input: "depth_net/cnv6b/weights" + input: "save/RestoreV2:23" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_24" + op: "Assign" + input: "depth_net/cnv7/biases" + input: "save/RestoreV2:24" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_25" + op: "Assign" + input: "depth_net/cnv7/weights" + input: "save/RestoreV2:25" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_26" + op: "Assign" + input: "depth_net/cnv7b/biases" + input: "save/RestoreV2:26" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_27" + op: "Assign" + input: "depth_net/cnv7b/weights" + input: "save/RestoreV2:27" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_28" + op: "Assign" + input: "depth_net/disp1/biases" + input: "save/RestoreV2:28" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_29" + op: "Assign" + input: "depth_net/disp1/weights" + input: "save/RestoreV2:29" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_30" + op: "Assign" + input: "depth_net/disp2/biases" + input: "save/RestoreV2:30" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_31" + op: "Assign" + input: "depth_net/disp2/weights" + input: "save/RestoreV2:31" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_32" + op: "Assign" + input: "depth_net/disp3/biases" + input: "save/RestoreV2:32" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_33" + op: "Assign" + input: "depth_net/disp3/weights" + input: "save/RestoreV2:33" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_34" + op: "Assign" + input: "depth_net/disp4/biases" + input: "save/RestoreV2:34" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_35" + op: "Assign" + input: "depth_net/disp4/weights" + input: "save/RestoreV2:35" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_36" + op: "Assign" + input: "depth_net/icnv1/biases" + input: "save/RestoreV2:36" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_37" + op: "Assign" + input: "depth_net/icnv1/weights" + input: "save/RestoreV2:37" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 17 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_38" + op: "Assign" + input: "depth_net/icnv2/biases" + input: "save/RestoreV2:38" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_39" + op: "Assign" + input: "depth_net/icnv2/weights" + input: "save/RestoreV2:39" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 65 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_40" + op: "Assign" + input: "depth_net/icnv3/biases" + input: "save/RestoreV2:40" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_41" + op: "Assign" + input: "depth_net/icnv3/weights" + input: "save/RestoreV2:41" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 129 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_42" + op: "Assign" + input: "depth_net/icnv4/biases" + input: "save/RestoreV2:42" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_43" + op: "Assign" + input: "depth_net/icnv4/weights" + input: "save/RestoreV2:43" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_44" + op: "Assign" + input: "depth_net/icnv5/biases" + input: "save/RestoreV2:44" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_45" + op: "Assign" + input: "depth_net/icnv5/weights" + input: "save/RestoreV2:45" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_46" + op: "Assign" + input: "depth_net/icnv6/biases" + input: "save/RestoreV2:46" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_47" + op: "Assign" + input: "depth_net/icnv6/weights" + input: "save/RestoreV2:47" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_48" + op: "Assign" + input: "depth_net/icnv7/biases" + input: "save/RestoreV2:48" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_49" + op: "Assign" + input: "depth_net/icnv7/weights" + input: "save/RestoreV2:49" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 1024 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_50" + op: "Assign" + input: "depth_net/upcnv1/biases" + input: "save/RestoreV2:50" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_51" + op: "Assign" + input: "depth_net/upcnv1/weights" + input: "save/RestoreV2:51" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_52" + op: "Assign" + input: "depth_net/upcnv2/biases" + input: "save/RestoreV2:52" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_53" + op: "Assign" + input: "depth_net/upcnv2/weights" + input: "save/RestoreV2:53" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_54" + op: "Assign" + input: "depth_net/upcnv3/biases" + input: "save/RestoreV2:54" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_55" + op: "Assign" + input: "depth_net/upcnv3/weights" + input: "save/RestoreV2:55" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_56" + op: "Assign" + input: "depth_net/upcnv4/biases" + input: "save/RestoreV2:56" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_57" + op: "Assign" + input: "depth_net/upcnv4/weights" + input: "save/RestoreV2:57" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_58" + op: "Assign" + input: "depth_net/upcnv5/biases" + input: "save/RestoreV2:58" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_59" + op: "Assign" + input: "depth_net/upcnv5/weights" + input: "save/RestoreV2:59" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_60" + op: "Assign" + input: "depth_net/upcnv6/biases" + input: "save/RestoreV2:60" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_61" + op: "Assign" + input: "depth_net/upcnv6/weights" + input: "save/RestoreV2:61" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_62" + op: "Assign" + input: "depth_net/upcnv7/biases" + input: "save/RestoreV2:62" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_63" + op: "Assign" + input: "depth_net/upcnv7/weights" + input: "save/RestoreV2:63" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 512 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_64" + op: "Assign" + input: "pose_exp_net/cnv1/biases" + input: "save/RestoreV2:64" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_65" + op: "Assign" + input: "pose_exp_net/cnv1/weights" + input: "save/RestoreV2:65" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 7 + } + dim { + size: 7 + } + dim { + size: 9 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_66" + op: "Assign" + input: "pose_exp_net/cnv2/biases" + input: "save/RestoreV2:66" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_67" + op: "Assign" + input: "pose_exp_net/cnv2/weights" + input: "save/RestoreV2:67" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 5 + } + dim { + size: 5 + } + dim { + size: 16 + } + dim { + size: 32 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_68" + op: "Assign" + input: "pose_exp_net/cnv3/biases" + input: "save/RestoreV2:68" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_69" + op: "Assign" + input: "pose_exp_net/cnv3/weights" + input: "save/RestoreV2:69" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 32 + } + dim { + size: 64 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_70" + op: "Assign" + input: "pose_exp_net/cnv4/biases" + input: "save/RestoreV2:70" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_71" + op: "Assign" + input: "pose_exp_net/cnv4/weights" + input: "save/RestoreV2:71" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 64 + } + dim { + size: 128 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_72" + op: "Assign" + input: "pose_exp_net/cnv5/biases" + input: "save/RestoreV2:72" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_73" + op: "Assign" + input: "pose_exp_net/cnv5/weights" + input: "save/RestoreV2:73" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 128 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_74" + op: "Assign" + input: "pose_exp_net/pose/cnv6/biases" + input: "save/RestoreV2:74" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_75" + op: "Assign" + input: "pose_exp_net/pose/cnv6/weights" + input: "save/RestoreV2:75" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_76" + op: "Assign" + input: "pose_exp_net/pose/cnv7/biases" + input: "save/RestoreV2:76" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_77" + op: "Assign" + input: "pose_exp_net/pose/cnv7/weights" + input: "save/RestoreV2:77" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + dim { + size: 3 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_78" + op: "Assign" + input: "pose_exp_net/pose/pred/biases" + input: "save/RestoreV2:78" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 12 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_79" + op: "Assign" + input: "pose_exp_net/pose/pred/weights" + input: "save/RestoreV2:79" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 256 + } + dim { + size: 12 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "save/Assign_80" + op: "Assign" + input: "train_op/global_step" + input: "save/RestoreV2:80" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@train_op/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_all" + op: "NoOp" + input: "^save/Assign" + input: "^save/Assign_1" + input: "^save/Assign_10" + input: "^save/Assign_11" + input: "^save/Assign_12" + input: "^save/Assign_13" + input: "^save/Assign_14" + input: "^save/Assign_15" + input: "^save/Assign_16" + input: "^save/Assign_17" + input: "^save/Assign_18" + input: "^save/Assign_19" + input: "^save/Assign_2" + input: "^save/Assign_20" + input: "^save/Assign_21" + input: "^save/Assign_22" + input: "^save/Assign_23" + input: "^save/Assign_24" + input: "^save/Assign_25" + input: "^save/Assign_26" + input: "^save/Assign_27" + input: "^save/Assign_28" + input: "^save/Assign_29" + input: "^save/Assign_3" + input: "^save/Assign_30" + input: "^save/Assign_31" + input: "^save/Assign_32" + input: "^save/Assign_33" + input: "^save/Assign_34" + input: "^save/Assign_35" + input: "^save/Assign_36" + input: "^save/Assign_37" + input: "^save/Assign_38" + input: "^save/Assign_39" + input: "^save/Assign_4" + input: "^save/Assign_40" + input: "^save/Assign_41" + input: "^save/Assign_42" + input: "^save/Assign_43" + input: "^save/Assign_44" + input: "^save/Assign_45" + input: "^save/Assign_46" + input: "^save/Assign_47" + input: "^save/Assign_48" + input: "^save/Assign_49" + input: "^save/Assign_5" + input: "^save/Assign_50" + input: "^save/Assign_51" + input: "^save/Assign_52" + input: "^save/Assign_53" + input: "^save/Assign_54" + input: "^save/Assign_55" + input: "^save/Assign_56" + input: "^save/Assign_57" + input: "^save/Assign_58" + input: "^save/Assign_59" + input: "^save/Assign_6" + input: "^save/Assign_60" + input: "^save/Assign_61" + input: "^save/Assign_62" + input: "^save/Assign_63" + input: "^save/Assign_64" + input: "^save/Assign_65" + input: "^save/Assign_66" + input: "^save/Assign_67" + input: "^save/Assign_68" + input: "^save/Assign_69" + input: "^save/Assign_7" + input: "^save/Assign_70" + input: "^save/Assign_71" + input: "^save/Assign_72" + input: "^save/Assign_73" + input: "^save/Assign_74" + input: "^save/Assign_75" + input: "^save/Assign_76" + input: "^save/Assign_77" + input: "^save/Assign_78" + input: "^save/Assign_79" + input: "^save/Assign_8" + input: "^save/Assign_80" + input: "^save/Assign_9" +} +node { + name: "report_uninitialized_variables/IsVariableInitialized" + op: "IsVariableInitialized" + input: "depth_net/cnv1/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_1" + op: "IsVariableInitialized" + input: "depth_net/cnv1/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_2" + op: "IsVariableInitialized" + input: "depth_net/cnv1b/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_3" + op: "IsVariableInitialized" + input: "depth_net/cnv1b/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_4" + op: "IsVariableInitialized" + input: "depth_net/cnv2/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_5" + op: "IsVariableInitialized" + input: "depth_net/cnv2/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_6" + op: "IsVariableInitialized" + input: "depth_net/cnv2b/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_7" + op: "IsVariableInitialized" + input: "depth_net/cnv2b/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_8" + op: "IsVariableInitialized" + input: "depth_net/cnv3/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_9" + op: "IsVariableInitialized" + input: "depth_net/cnv3/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_10" + op: "IsVariableInitialized" + input: "depth_net/cnv3b/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_11" + op: "IsVariableInitialized" + input: "depth_net/cnv3b/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_12" + op: "IsVariableInitialized" + input: "depth_net/cnv4/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_13" + op: "IsVariableInitialized" + input: "depth_net/cnv4/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_14" + op: "IsVariableInitialized" + input: "depth_net/cnv4b/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_15" + op: "IsVariableInitialized" + input: "depth_net/cnv4b/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_16" + op: "IsVariableInitialized" + input: "depth_net/cnv5/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_17" + op: "IsVariableInitialized" + input: "depth_net/cnv5/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_18" + op: "IsVariableInitialized" + input: "depth_net/cnv5b/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_19" + op: "IsVariableInitialized" + input: "depth_net/cnv5b/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_20" + op: "IsVariableInitialized" + input: "depth_net/cnv6/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_21" + op: "IsVariableInitialized" + input: "depth_net/cnv6/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_22" + op: "IsVariableInitialized" + input: "depth_net/cnv6b/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_23" + op: "IsVariableInitialized" + input: "depth_net/cnv6b/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_24" + op: "IsVariableInitialized" + input: "depth_net/cnv7/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_25" + op: "IsVariableInitialized" + input: "depth_net/cnv7/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_26" + op: "IsVariableInitialized" + input: "depth_net/cnv7b/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_27" + op: "IsVariableInitialized" + input: "depth_net/cnv7b/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_28" + op: "IsVariableInitialized" + input: "depth_net/upcnv7/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_29" + op: "IsVariableInitialized" + input: "depth_net/upcnv7/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_30" + op: "IsVariableInitialized" + input: "depth_net/icnv7/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_31" + op: "IsVariableInitialized" + input: "depth_net/icnv7/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_32" + op: "IsVariableInitialized" + input: "depth_net/upcnv6/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_33" + op: "IsVariableInitialized" + input: "depth_net/upcnv6/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_34" + op: "IsVariableInitialized" + input: "depth_net/icnv6/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_35" + op: "IsVariableInitialized" + input: "depth_net/icnv6/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_36" + op: "IsVariableInitialized" + input: "depth_net/upcnv5/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_37" + op: "IsVariableInitialized" + input: "depth_net/upcnv5/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_38" + op: "IsVariableInitialized" + input: "depth_net/icnv5/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_39" + op: "IsVariableInitialized" + input: "depth_net/icnv5/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_40" + op: "IsVariableInitialized" + input: "depth_net/upcnv4/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_41" + op: "IsVariableInitialized" + input: "depth_net/upcnv4/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_42" + op: "IsVariableInitialized" + input: "depth_net/icnv4/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_43" + op: "IsVariableInitialized" + input: "depth_net/icnv4/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_44" + op: "IsVariableInitialized" + input: "depth_net/disp4/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_45" + op: "IsVariableInitialized" + input: "depth_net/disp4/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_46" + op: "IsVariableInitialized" + input: "depth_net/upcnv3/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_47" + op: "IsVariableInitialized" + input: "depth_net/upcnv3/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_48" + op: "IsVariableInitialized" + input: "depth_net/icnv3/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_49" + op: "IsVariableInitialized" + input: "depth_net/icnv3/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_50" + op: "IsVariableInitialized" + input: "depth_net/disp3/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_51" + op: "IsVariableInitialized" + input: "depth_net/disp3/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_52" + op: "IsVariableInitialized" + input: "depth_net/upcnv2/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_53" + op: "IsVariableInitialized" + input: "depth_net/upcnv2/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_54" + op: "IsVariableInitialized" + input: "depth_net/icnv2/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_55" + op: "IsVariableInitialized" + input: "depth_net/icnv2/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_56" + op: "IsVariableInitialized" + input: "depth_net/disp2/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_57" + op: "IsVariableInitialized" + input: "depth_net/disp2/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_58" + op: "IsVariableInitialized" + input: "depth_net/upcnv1/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_59" + op: "IsVariableInitialized" + input: "depth_net/upcnv1/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_60" + op: "IsVariableInitialized" + input: "depth_net/icnv1/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_61" + op: "IsVariableInitialized" + input: "depth_net/icnv1/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_62" + op: "IsVariableInitialized" + input: "depth_net/disp1/weights" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_63" + op: "IsVariableInitialized" + input: "depth_net/disp1/biases" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_64" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv1/weights" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_65" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv1/biases" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_66" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv2/weights" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_67" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv2/biases" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_68" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv3/weights" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_69" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv3/biases" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_70" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv4/weights" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_71" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv4/biases" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_72" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv5/weights" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_73" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv5/biases" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_74" + op: "IsVariableInitialized" + input: "pose_exp_net/pose/cnv6/weights" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_75" + op: "IsVariableInitialized" + input: "pose_exp_net/pose/cnv6/biases" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_76" + op: "IsVariableInitialized" + input: "pose_exp_net/pose/cnv7/weights" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_77" + op: "IsVariableInitialized" + input: "pose_exp_net/pose/cnv7/biases" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_78" + op: "IsVariableInitialized" + input: "pose_exp_net/pose/pred/weights" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_79" + op: "IsVariableInitialized" + input: "pose_exp_net/pose/pred/biases" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_80" + 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_81" + op: "IsVariableInitialized" + input: "train_op/beta1_power" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_82" + op: "IsVariableInitialized" + input: "train_op/beta2_power" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_83" + op: "IsVariableInitialized" + input: "depth_net/cnv1/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_84" + op: "IsVariableInitialized" + input: "depth_net/cnv1/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_85" + op: "IsVariableInitialized" + input: "depth_net/cnv1/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_86" + op: "IsVariableInitialized" + input: "depth_net/cnv1/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_87" + op: "IsVariableInitialized" + input: "depth_net/cnv1b/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_88" + op: "IsVariableInitialized" + input: "depth_net/cnv1b/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_89" + op: "IsVariableInitialized" + input: "depth_net/cnv1b/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_90" + op: "IsVariableInitialized" + input: "depth_net/cnv1b/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv1b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_91" + op: "IsVariableInitialized" + input: "depth_net/cnv2/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_92" + op: "IsVariableInitialized" + input: "depth_net/cnv2/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_93" + op: "IsVariableInitialized" + input: "depth_net/cnv2/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_94" + op: "IsVariableInitialized" + input: "depth_net/cnv2/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_95" + op: "IsVariableInitialized" + input: "depth_net/cnv2b/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_96" + op: "IsVariableInitialized" + input: "depth_net/cnv2b/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_97" + op: "IsVariableInitialized" + input: "depth_net/cnv2b/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_98" + op: "IsVariableInitialized" + input: "depth_net/cnv2b/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv2b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_99" + op: "IsVariableInitialized" + input: "depth_net/cnv3/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_100" + op: "IsVariableInitialized" + input: "depth_net/cnv3/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_101" + op: "IsVariableInitialized" + input: "depth_net/cnv3/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_102" + op: "IsVariableInitialized" + input: "depth_net/cnv3/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_103" + op: "IsVariableInitialized" + input: "depth_net/cnv3b/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_104" + op: "IsVariableInitialized" + input: "depth_net/cnv3b/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_105" + op: "IsVariableInitialized" + input: "depth_net/cnv3b/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_106" + op: "IsVariableInitialized" + input: "depth_net/cnv3b/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv3b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_107" + op: "IsVariableInitialized" + input: "depth_net/cnv4/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_108" + op: "IsVariableInitialized" + input: "depth_net/cnv4/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_109" + op: "IsVariableInitialized" + input: "depth_net/cnv4/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_110" + op: "IsVariableInitialized" + input: "depth_net/cnv4/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_111" + op: "IsVariableInitialized" + input: "depth_net/cnv4b/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_112" + op: "IsVariableInitialized" + input: "depth_net/cnv4b/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_113" + op: "IsVariableInitialized" + input: "depth_net/cnv4b/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_114" + op: "IsVariableInitialized" + input: "depth_net/cnv4b/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv4b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_115" + op: "IsVariableInitialized" + input: "depth_net/cnv5/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_116" + op: "IsVariableInitialized" + input: "depth_net/cnv5/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_117" + op: "IsVariableInitialized" + input: "depth_net/cnv5/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_118" + op: "IsVariableInitialized" + input: "depth_net/cnv5/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_119" + op: "IsVariableInitialized" + input: "depth_net/cnv5b/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_120" + op: "IsVariableInitialized" + input: "depth_net/cnv5b/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_121" + op: "IsVariableInitialized" + input: "depth_net/cnv5b/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_122" + op: "IsVariableInitialized" + input: "depth_net/cnv5b/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv5b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_123" + op: "IsVariableInitialized" + input: "depth_net/cnv6/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_124" + op: "IsVariableInitialized" + input: "depth_net/cnv6/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_125" + op: "IsVariableInitialized" + input: "depth_net/cnv6/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_126" + op: "IsVariableInitialized" + input: "depth_net/cnv6/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_127" + op: "IsVariableInitialized" + input: "depth_net/cnv6b/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_128" + op: "IsVariableInitialized" + input: "depth_net/cnv6b/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_129" + op: "IsVariableInitialized" + input: "depth_net/cnv6b/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_130" + op: "IsVariableInitialized" + input: "depth_net/cnv6b/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv6b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_131" + op: "IsVariableInitialized" + input: "depth_net/cnv7/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_132" + op: "IsVariableInitialized" + input: "depth_net/cnv7/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_133" + op: "IsVariableInitialized" + input: "depth_net/cnv7/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_134" + op: "IsVariableInitialized" + input: "depth_net/cnv7/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_135" + op: "IsVariableInitialized" + input: "depth_net/cnv7b/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_136" + op: "IsVariableInitialized" + input: "depth_net/cnv7b/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_137" + op: "IsVariableInitialized" + input: "depth_net/cnv7b/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_138" + op: "IsVariableInitialized" + input: "depth_net/cnv7b/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/cnv7b/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_139" + op: "IsVariableInitialized" + input: "depth_net/upcnv7/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_140" + op: "IsVariableInitialized" + input: "depth_net/upcnv7/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_141" + op: "IsVariableInitialized" + input: "depth_net/upcnv7/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_142" + op: "IsVariableInitialized" + input: "depth_net/upcnv7/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_143" + op: "IsVariableInitialized" + input: "depth_net/icnv7/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_144" + op: "IsVariableInitialized" + input: "depth_net/icnv7/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_145" + op: "IsVariableInitialized" + input: "depth_net/icnv7/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_146" + op: "IsVariableInitialized" + input: "depth_net/icnv7/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_147" + op: "IsVariableInitialized" + input: "depth_net/upcnv6/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_148" + op: "IsVariableInitialized" + input: "depth_net/upcnv6/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_149" + op: "IsVariableInitialized" + input: "depth_net/upcnv6/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_150" + op: "IsVariableInitialized" + input: "depth_net/upcnv6/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_151" + op: "IsVariableInitialized" + input: "depth_net/icnv6/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_152" + op: "IsVariableInitialized" + input: "depth_net/icnv6/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_153" + op: "IsVariableInitialized" + input: "depth_net/icnv6/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_154" + op: "IsVariableInitialized" + input: "depth_net/icnv6/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_155" + op: "IsVariableInitialized" + input: "depth_net/upcnv5/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_156" + op: "IsVariableInitialized" + input: "depth_net/upcnv5/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_157" + op: "IsVariableInitialized" + input: "depth_net/upcnv5/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_158" + op: "IsVariableInitialized" + input: "depth_net/upcnv5/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_159" + op: "IsVariableInitialized" + input: "depth_net/icnv5/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_160" + op: "IsVariableInitialized" + input: "depth_net/icnv5/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_161" + op: "IsVariableInitialized" + input: "depth_net/icnv5/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_162" + op: "IsVariableInitialized" + input: "depth_net/icnv5/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_163" + op: "IsVariableInitialized" + input: "depth_net/upcnv4/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_164" + op: "IsVariableInitialized" + input: "depth_net/upcnv4/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_165" + op: "IsVariableInitialized" + input: "depth_net/upcnv4/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_166" + op: "IsVariableInitialized" + input: "depth_net/upcnv4/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_167" + op: "IsVariableInitialized" + input: "depth_net/icnv4/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_168" + op: "IsVariableInitialized" + input: "depth_net/icnv4/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_169" + op: "IsVariableInitialized" + input: "depth_net/icnv4/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_170" + op: "IsVariableInitialized" + input: "depth_net/icnv4/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_171" + op: "IsVariableInitialized" + input: "depth_net/disp4/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_172" + op: "IsVariableInitialized" + input: "depth_net/disp4/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_173" + op: "IsVariableInitialized" + input: "depth_net/disp4/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_174" + op: "IsVariableInitialized" + input: "depth_net/disp4/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_175" + op: "IsVariableInitialized" + input: "depth_net/upcnv3/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_176" + op: "IsVariableInitialized" + input: "depth_net/upcnv3/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_177" + op: "IsVariableInitialized" + input: "depth_net/upcnv3/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_178" + op: "IsVariableInitialized" + input: "depth_net/upcnv3/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_179" + op: "IsVariableInitialized" + input: "depth_net/icnv3/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_180" + op: "IsVariableInitialized" + input: "depth_net/icnv3/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_181" + op: "IsVariableInitialized" + input: "depth_net/icnv3/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_182" + op: "IsVariableInitialized" + input: "depth_net/icnv3/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_183" + op: "IsVariableInitialized" + input: "depth_net/disp3/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_184" + op: "IsVariableInitialized" + input: "depth_net/disp3/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_185" + op: "IsVariableInitialized" + input: "depth_net/disp3/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_186" + op: "IsVariableInitialized" + input: "depth_net/disp3/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_187" + op: "IsVariableInitialized" + input: "depth_net/upcnv2/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_188" + op: "IsVariableInitialized" + input: "depth_net/upcnv2/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_189" + op: "IsVariableInitialized" + input: "depth_net/upcnv2/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_190" + op: "IsVariableInitialized" + input: "depth_net/upcnv2/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_191" + op: "IsVariableInitialized" + input: "depth_net/icnv2/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_192" + op: "IsVariableInitialized" + input: "depth_net/icnv2/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_193" + op: "IsVariableInitialized" + input: "depth_net/icnv2/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_194" + op: "IsVariableInitialized" + input: "depth_net/icnv2/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_195" + op: "IsVariableInitialized" + input: "depth_net/disp2/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_196" + op: "IsVariableInitialized" + input: "depth_net/disp2/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_197" + op: "IsVariableInitialized" + input: "depth_net/disp2/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_198" + op: "IsVariableInitialized" + input: "depth_net/disp2/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_199" + op: "IsVariableInitialized" + input: "depth_net/upcnv1/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_200" + op: "IsVariableInitialized" + input: "depth_net/upcnv1/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_201" + op: "IsVariableInitialized" + input: "depth_net/upcnv1/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_202" + op: "IsVariableInitialized" + input: "depth_net/upcnv1/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/upcnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_203" + op: "IsVariableInitialized" + input: "depth_net/icnv1/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_204" + op: "IsVariableInitialized" + input: "depth_net/icnv1/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_205" + op: "IsVariableInitialized" + input: "depth_net/icnv1/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_206" + op: "IsVariableInitialized" + input: "depth_net/icnv1/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/icnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_207" + op: "IsVariableInitialized" + input: "depth_net/disp1/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_208" + op: "IsVariableInitialized" + input: "depth_net/disp1/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_209" + op: "IsVariableInitialized" + input: "depth_net/disp1/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_210" + op: "IsVariableInitialized" + input: "depth_net/disp1/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@depth_net/disp1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_211" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv1/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_212" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv1/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_213" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv1/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_214" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv1/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv1/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_215" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv2/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_216" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv2/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_217" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv2/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_218" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv2/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv2/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_219" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv3/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_220" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv3/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_221" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv3/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_222" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv3/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv3/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_223" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv4/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_224" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv4/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_225" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv4/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_226" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv4/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv4/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_227" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv5/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_228" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv5/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_229" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv5/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_230" + op: "IsVariableInitialized" + input: "pose_exp_net/cnv5/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/cnv5/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_231" + op: "IsVariableInitialized" + input: "pose_exp_net/pose/cnv6/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_232" + op: "IsVariableInitialized" + input: "pose_exp_net/pose/cnv6/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_233" + op: "IsVariableInitialized" + input: "pose_exp_net/pose/cnv6/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_234" + op: "IsVariableInitialized" + input: "pose_exp_net/pose/cnv6/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv6/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_235" + op: "IsVariableInitialized" + input: "pose_exp_net/pose/cnv7/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_236" + op: "IsVariableInitialized" + input: "pose_exp_net/pose/cnv7/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_237" + op: "IsVariableInitialized" + input: "pose_exp_net/pose/cnv7/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_238" + op: "IsVariableInitialized" + input: "pose_exp_net/pose/cnv7/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/cnv7/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_239" + op: "IsVariableInitialized" + input: "pose_exp_net/pose/pred/weights/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_240" + op: "IsVariableInitialized" + input: "pose_exp_net/pose/pred/weights/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/weights" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_241" + op: "IsVariableInitialized" + input: "pose_exp_net/pose/pred/biases/Adam" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_242" + op: "IsVariableInitialized" + input: "pose_exp_net/pose/pred/biases/Adam_1" + attr { + key: "_class" + value { + list { + s: "loc:@pose_exp_net/pose/pred/biases" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "report_uninitialized_variables/IsVariableInitialized_243" + op: "IsVariableInitialized" + input: "train_op/global_step" + attr { + key: "_class" + value { + list { + s: "loc:@train_op/global_step" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } +} +node { + name: "report_uninitialized_variables/stack" + op: "Pack" + input: "report_uninitialized_variables/IsVariableInitialized" + input: "report_uninitialized_variables/IsVariableInitialized_1" + input: "report_uninitialized_variables/IsVariableInitialized_2" + input: "report_uninitialized_variables/IsVariableInitialized_3" + input: "report_uninitialized_variables/IsVariableInitialized_4" + input: "report_uninitialized_variables/IsVariableInitialized_5" + input: "report_uninitialized_variables/IsVariableInitialized_6" + input: "report_uninitialized_variables/IsVariableInitialized_7" + input: "report_uninitialized_variables/IsVariableInitialized_8" + input: "report_uninitialized_variables/IsVariableInitialized_9" + input: "report_uninitialized_variables/IsVariableInitialized_10" + input: "report_uninitialized_variables/IsVariableInitialized_11" + input: "report_uninitialized_variables/IsVariableInitialized_12" + input: "report_uninitialized_variables/IsVariableInitialized_13" + input: "report_uninitialized_variables/IsVariableInitialized_14" + input: "report_uninitialized_variables/IsVariableInitialized_15" + input: "report_uninitialized_variables/IsVariableInitialized_16" + input: "report_uninitialized_variables/IsVariableInitialized_17" + input: "report_uninitialized_variables/IsVariableInitialized_18" + input: "report_uninitialized_variables/IsVariableInitialized_19" + input: "report_uninitialized_variables/IsVariableInitialized_20" + input: "report_uninitialized_variables/IsVariableInitialized_21" + input: "report_uninitialized_variables/IsVariableInitialized_22" + input: "report_uninitialized_variables/IsVariableInitialized_23" + input: "report_uninitialized_variables/IsVariableInitialized_24" + input: "report_uninitialized_variables/IsVariableInitialized_25" + input: "report_uninitialized_variables/IsVariableInitialized_26" + input: "report_uninitialized_variables/IsVariableInitialized_27" + input: "report_uninitialized_variables/IsVariableInitialized_28" + input: "report_uninitialized_variables/IsVariableInitialized_29" + input: "report_uninitialized_variables/IsVariableInitialized_30" + input: "report_uninitialized_variables/IsVariableInitialized_31" + input: "report_uninitialized_variables/IsVariableInitialized_32" + input: "report_uninitialized_variables/IsVariableInitialized_33" + input: "report_uninitialized_variables/IsVariableInitialized_34" + input: "report_uninitialized_variables/IsVariableInitialized_35" + input: "report_uninitialized_variables/IsVariableInitialized_36" + input: "report_uninitialized_variables/IsVariableInitialized_37" + input: "report_uninitialized_variables/IsVariableInitialized_38" + input: "report_uninitialized_variables/IsVariableInitialized_39" + input: "report_uninitialized_variables/IsVariableInitialized_40" + input: "report_uninitialized_variables/IsVariableInitialized_41" + input: "report_uninitialized_variables/IsVariableInitialized_42" + input: "report_uninitialized_variables/IsVariableInitialized_43" + input: "report_uninitialized_variables/IsVariableInitialized_44" + input: "report_uninitialized_variables/IsVariableInitialized_45" + input: "report_uninitialized_variables/IsVariableInitialized_46" + input: "report_uninitialized_variables/IsVariableInitialized_47" + input: "report_uninitialized_variables/IsVariableInitialized_48" + input: "report_uninitialized_variables/IsVariableInitialized_49" + input: "report_uninitialized_variables/IsVariableInitialized_50" + input: "report_uninitialized_variables/IsVariableInitialized_51" + input: "report_uninitialized_variables/IsVariableInitialized_52" + input: "report_uninitialized_variables/IsVariableInitialized_53" + input: "report_uninitialized_variables/IsVariableInitialized_54" + input: "report_uninitialized_variables/IsVariableInitialized_55" + input: "report_uninitialized_variables/IsVariableInitialized_56" + input: "report_uninitialized_variables/IsVariableInitialized_57" + input: "report_uninitialized_variables/IsVariableInitialized_58" + input: "report_uninitialized_variables/IsVariableInitialized_59" + input: "report_uninitialized_variables/IsVariableInitialized_60" + input: "report_uninitialized_variables/IsVariableInitialized_61" + input: "report_uninitialized_variables/IsVariableInitialized_62" + input: "report_uninitialized_variables/IsVariableInitialized_63" + input: "report_uninitialized_variables/IsVariableInitialized_64" + input: "report_uninitialized_variables/IsVariableInitialized_65" + input: "report_uninitialized_variables/IsVariableInitialized_66" + input: "report_uninitialized_variables/IsVariableInitialized_67" + input: "report_uninitialized_variables/IsVariableInitialized_68" + input: "report_uninitialized_variables/IsVariableInitialized_69" + input: "report_uninitialized_variables/IsVariableInitialized_70" + input: "report_uninitialized_variables/IsVariableInitialized_71" + input: "report_uninitialized_variables/IsVariableInitialized_72" + input: "report_uninitialized_variables/IsVariableInitialized_73" + input: "report_uninitialized_variables/IsVariableInitialized_74" + input: "report_uninitialized_variables/IsVariableInitialized_75" + input: "report_uninitialized_variables/IsVariableInitialized_76" + input: "report_uninitialized_variables/IsVariableInitialized_77" + input: "report_uninitialized_variables/IsVariableInitialized_78" + input: "report_uninitialized_variables/IsVariableInitialized_79" + input: "report_uninitialized_variables/IsVariableInitialized_80" + input: "report_uninitialized_variables/IsVariableInitialized_81" + input: "report_uninitialized_variables/IsVariableInitialized_82" + input: "report_uninitialized_variables/IsVariableInitialized_83" + input: "report_uninitialized_variables/IsVariableInitialized_84" + input: "report_uninitialized_variables/IsVariableInitialized_85" + input: "report_uninitialized_variables/IsVariableInitialized_86" + input: "report_uninitialized_variables/IsVariableInitialized_87" + input: "report_uninitialized_variables/IsVariableInitialized_88" + input: "report_uninitialized_variables/IsVariableInitialized_89" + input: "report_uninitialized_variables/IsVariableInitialized_90" + input: "report_uninitialized_variables/IsVariableInitialized_91" + input: "report_uninitialized_variables/IsVariableInitialized_92" + input: "report_uninitialized_variables/IsVariableInitialized_93" + input: "report_uninitialized_variables/IsVariableInitialized_94" + input: "report_uninitialized_variables/IsVariableInitialized_95" + input: "report_uninitialized_variables/IsVariableInitialized_96" + input: "report_uninitialized_variables/IsVariableInitialized_97" + input: "report_uninitialized_variables/IsVariableInitialized_98" + input: "report_uninitialized_variables/IsVariableInitialized_99" + input: "report_uninitialized_variables/IsVariableInitialized_100" + input: "report_uninitialized_variables/IsVariableInitialized_101" + input: "report_uninitialized_variables/IsVariableInitialized_102" + input: "report_uninitialized_variables/IsVariableInitialized_103" + input: "report_uninitialized_variables/IsVariableInitialized_104" + input: "report_uninitialized_variables/IsVariableInitialized_105" + input: "report_uninitialized_variables/IsVariableInitialized_106" + input: "report_uninitialized_variables/IsVariableInitialized_107" + input: "report_uninitialized_variables/IsVariableInitialized_108" + input: "report_uninitialized_variables/IsVariableInitialized_109" + input: "report_uninitialized_variables/IsVariableInitialized_110" + input: "report_uninitialized_variables/IsVariableInitialized_111" + input: "report_uninitialized_variables/IsVariableInitialized_112" + input: "report_uninitialized_variables/IsVariableInitialized_113" + input: "report_uninitialized_variables/IsVariableInitialized_114" + input: "report_uninitialized_variables/IsVariableInitialized_115" + input: "report_uninitialized_variables/IsVariableInitialized_116" + input: "report_uninitialized_variables/IsVariableInitialized_117" + input: "report_uninitialized_variables/IsVariableInitialized_118" + input: "report_uninitialized_variables/IsVariableInitialized_119" + input: "report_uninitialized_variables/IsVariableInitialized_120" + input: "report_uninitialized_variables/IsVariableInitialized_121" + input: "report_uninitialized_variables/IsVariableInitialized_122" + input: "report_uninitialized_variables/IsVariableInitialized_123" + input: "report_uninitialized_variables/IsVariableInitialized_124" + input: "report_uninitialized_variables/IsVariableInitialized_125" + input: "report_uninitialized_variables/IsVariableInitialized_126" + input: "report_uninitialized_variables/IsVariableInitialized_127" + input: "report_uninitialized_variables/IsVariableInitialized_128" + input: "report_uninitialized_variables/IsVariableInitialized_129" + input: "report_uninitialized_variables/IsVariableInitialized_130" + input: "report_uninitialized_variables/IsVariableInitialized_131" + input: "report_uninitialized_variables/IsVariableInitialized_132" + input: "report_uninitialized_variables/IsVariableInitialized_133" + input: "report_uninitialized_variables/IsVariableInitialized_134" + input: "report_uninitialized_variables/IsVariableInitialized_135" + input: "report_uninitialized_variables/IsVariableInitialized_136" + input: "report_uninitialized_variables/IsVariableInitialized_137" + input: "report_uninitialized_variables/IsVariableInitialized_138" + input: "report_uninitialized_variables/IsVariableInitialized_139" + input: "report_uninitialized_variables/IsVariableInitialized_140" + input: "report_uninitialized_variables/IsVariableInitialized_141" + input: "report_uninitialized_variables/IsVariableInitialized_142" + input: "report_uninitialized_variables/IsVariableInitialized_143" + input: "report_uninitialized_variables/IsVariableInitialized_144" + input: "report_uninitialized_variables/IsVariableInitialized_145" + input: "report_uninitialized_variables/IsVariableInitialized_146" + input: "report_uninitialized_variables/IsVariableInitialized_147" + input: "report_uninitialized_variables/IsVariableInitialized_148" + input: "report_uninitialized_variables/IsVariableInitialized_149" + input: "report_uninitialized_variables/IsVariableInitialized_150" + input: "report_uninitialized_variables/IsVariableInitialized_151" + input: "report_uninitialized_variables/IsVariableInitialized_152" + input: "report_uninitialized_variables/IsVariableInitialized_153" + input: "report_uninitialized_variables/IsVariableInitialized_154" + input: "report_uninitialized_variables/IsVariableInitialized_155" + input: "report_uninitialized_variables/IsVariableInitialized_156" + input: "report_uninitialized_variables/IsVariableInitialized_157" + input: "report_uninitialized_variables/IsVariableInitialized_158" + input: "report_uninitialized_variables/IsVariableInitialized_159" + input: "report_uninitialized_variables/IsVariableInitialized_160" + input: "report_uninitialized_variables/IsVariableInitialized_161" + input: "report_uninitialized_variables/IsVariableInitialized_162" + input: "report_uninitialized_variables/IsVariableInitialized_163" + input: "report_uninitialized_variables/IsVariableInitialized_164" + input: "report_uninitialized_variables/IsVariableInitialized_165" + input: "report_uninitialized_variables/IsVariableInitialized_166" + input: "report_uninitialized_variables/IsVariableInitialized_167" + input: "report_uninitialized_variables/IsVariableInitialized_168" + input: "report_uninitialized_variables/IsVariableInitialized_169" + input: "report_uninitialized_variables/IsVariableInitialized_170" + input: "report_uninitialized_variables/IsVariableInitialized_171" + input: "report_uninitialized_variables/IsVariableInitialized_172" + input: "report_uninitialized_variables/IsVariableInitialized_173" + input: "report_uninitialized_variables/IsVariableInitialized_174" + input: "report_uninitialized_variables/IsVariableInitialized_175" + input: "report_uninitialized_variables/IsVariableInitialized_176" + input: "report_uninitialized_variables/IsVariableInitialized_177" + input: "report_uninitialized_variables/IsVariableInitialized_178" + input: "report_uninitialized_variables/IsVariableInitialized_179" + input: "report_uninitialized_variables/IsVariableInitialized_180" + input: "report_uninitialized_variables/IsVariableInitialized_181" + input: "report_uninitialized_variables/IsVariableInitialized_182" + input: "report_uninitialized_variables/IsVariableInitialized_183" + input: "report_uninitialized_variables/IsVariableInitialized_184" + input: "report_uninitialized_variables/IsVariableInitialized_185" + input: "report_uninitialized_variables/IsVariableInitialized_186" + input: "report_uninitialized_variables/IsVariableInitialized_187" + input: "report_uninitialized_variables/IsVariableInitialized_188" + input: "report_uninitialized_variables/IsVariableInitialized_189" + input: "report_uninitialized_variables/IsVariableInitialized_190" + input: "report_uninitialized_variables/IsVariableInitialized_191" + input: "report_uninitialized_variables/IsVariableInitialized_192" + input: "report_uninitialized_variables/IsVariableInitialized_193" + input: "report_uninitialized_variables/IsVariableInitialized_194" + input: "report_uninitialized_variables/IsVariableInitialized_195" + input: "report_uninitialized_variables/IsVariableInitialized_196" + input: "report_uninitialized_variables/IsVariableInitialized_197" + input: "report_uninitialized_variables/IsVariableInitialized_198" + input: "report_uninitialized_variables/IsVariableInitialized_199" + input: "report_uninitialized_variables/IsVariableInitialized_200" + input: "report_uninitialized_variables/IsVariableInitialized_201" + input: "report_uninitialized_variables/IsVariableInitialized_202" + input: "report_uninitialized_variables/IsVariableInitialized_203" + input: "report_uninitialized_variables/IsVariableInitialized_204" + input: "report_uninitialized_variables/IsVariableInitialized_205" + input: "report_uninitialized_variables/IsVariableInitialized_206" + input: "report_uninitialized_variables/IsVariableInitialized_207" + input: "report_uninitialized_variables/IsVariableInitialized_208" + input: "report_uninitialized_variables/IsVariableInitialized_209" + input: "report_uninitialized_variables/IsVariableInitialized_210" + input: "report_uninitialized_variables/IsVariableInitialized_211" + input: "report_uninitialized_variables/IsVariableInitialized_212" + input: "report_uninitialized_variables/IsVariableInitialized_213" + input: "report_uninitialized_variables/IsVariableInitialized_214" + input: "report_uninitialized_variables/IsVariableInitialized_215" + input: "report_uninitialized_variables/IsVariableInitialized_216" + input: "report_uninitialized_variables/IsVariableInitialized_217" + input: "report_uninitialized_variables/IsVariableInitialized_218" + input: "report_uninitialized_variables/IsVariableInitialized_219" + input: "report_uninitialized_variables/IsVariableInitialized_220" + input: "report_uninitialized_variables/IsVariableInitialized_221" + input: "report_uninitialized_variables/IsVariableInitialized_222" + input: "report_uninitialized_variables/IsVariableInitialized_223" + input: "report_uninitialized_variables/IsVariableInitialized_224" + input: "report_uninitialized_variables/IsVariableInitialized_225" + input: "report_uninitialized_variables/IsVariableInitialized_226" + input: "report_uninitialized_variables/IsVariableInitialized_227" + input: "report_uninitialized_variables/IsVariableInitialized_228" + input: "report_uninitialized_variables/IsVariableInitialized_229" + input: "report_uninitialized_variables/IsVariableInitialized_230" + input: "report_uninitialized_variables/IsVariableInitialized_231" + input: "report_uninitialized_variables/IsVariableInitialized_232" + input: "report_uninitialized_variables/IsVariableInitialized_233" + input: "report_uninitialized_variables/IsVariableInitialized_234" + input: "report_uninitialized_variables/IsVariableInitialized_235" + input: "report_uninitialized_variables/IsVariableInitialized_236" + input: "report_uninitialized_variables/IsVariableInitialized_237" + input: "report_uninitialized_variables/IsVariableInitialized_238" + input: "report_uninitialized_variables/IsVariableInitialized_239" + input: "report_uninitialized_variables/IsVariableInitialized_240" + input: "report_uninitialized_variables/IsVariableInitialized_241" + input: "report_uninitialized_variables/IsVariableInitialized_242" + input: "report_uninitialized_variables/IsVariableInitialized_243" + device: "/device:CPU:0" + attr { + key: "N" + value { + i: 244 + } + } + attr { + key: "T" + value { + type: DT_BOOL + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 244 + } + } + } + } + } + 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: 244 + } + } + } + } + } +} +node { + name: "report_uninitialized_variables/Const" + op: "Const" + device: "/device:CPU:0" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 244 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + dim { + size: 244 + } + } + string_val: "depth_net/cnv1/weights" + string_val: "depth_net/cnv1/biases" + string_val: "depth_net/cnv1b/weights" + string_val: "depth_net/cnv1b/biases" + string_val: "depth_net/cnv2/weights" + string_val: "depth_net/cnv2/biases" + string_val: "depth_net/cnv2b/weights" + string_val: "depth_net/cnv2b/biases" + string_val: "depth_net/cnv3/weights" + string_val: "depth_net/cnv3/biases" + string_val: "depth_net/cnv3b/weights" + string_val: "depth_net/cnv3b/biases" + string_val: "depth_net/cnv4/weights" + string_val: "depth_net/cnv4/biases" + string_val: "depth_net/cnv4b/weights" + string_val: "depth_net/cnv4b/biases" + string_val: "depth_net/cnv5/weights" + string_val: "depth_net/cnv5/biases" + string_val: "depth_net/cnv5b/weights" + string_val: "depth_net/cnv5b/biases" + string_val: "depth_net/cnv6/weights" + string_val: "depth_net/cnv6/biases" + string_val: "depth_net/cnv6b/weights" + string_val: "depth_net/cnv6b/biases" + string_val: "depth_net/cnv7/weights" + string_val: "depth_net/cnv7/biases" + string_val: "depth_net/cnv7b/weights" + string_val: "depth_net/cnv7b/biases" + string_val: "depth_net/upcnv7/weights" + string_val: "depth_net/upcnv7/biases" + string_val: "depth_net/icnv7/weights" + string_val: "depth_net/icnv7/biases" + string_val: "depth_net/upcnv6/weights" + string_val: "depth_net/upcnv6/biases" + string_val: "depth_net/icnv6/weights" + string_val: "depth_net/icnv6/biases" + string_val: "depth_net/upcnv5/weights" + string_val: "depth_net/upcnv5/biases" + string_val: "depth_net/icnv5/weights" + string_val: "depth_net/icnv5/biases" + string_val: "depth_net/upcnv4/weights" + string_val: "depth_net/upcnv4/biases" + string_val: "depth_net/icnv4/weights" + string_val: "depth_net/icnv4/biases" + string_val: "depth_net/disp4/weights" + string_val: "depth_net/disp4/biases" + string_val: "depth_net/upcnv3/weights" + string_val: "depth_net/upcnv3/biases" + string_val: "depth_net/icnv3/weights" + string_val: "depth_net/icnv3/biases" + string_val: "depth_net/disp3/weights" + string_val: "depth_net/disp3/biases" + string_val: "depth_net/upcnv2/weights" + string_val: "depth_net/upcnv2/biases" + string_val: "depth_net/icnv2/weights" + string_val: "depth_net/icnv2/biases" + string_val: "depth_net/disp2/weights" + string_val: "depth_net/disp2/biases" + string_val: "depth_net/upcnv1/weights" + string_val: "depth_net/upcnv1/biases" + string_val: "depth_net/icnv1/weights" + string_val: "depth_net/icnv1/biases" + string_val: "depth_net/disp1/weights" + string_val: "depth_net/disp1/biases" + string_val: "pose_exp_net/cnv1/weights" + string_val: "pose_exp_net/cnv1/biases" + string_val: "pose_exp_net/cnv2/weights" + string_val: "pose_exp_net/cnv2/biases" + string_val: "pose_exp_net/cnv3/weights" + string_val: "pose_exp_net/cnv3/biases" + string_val: "pose_exp_net/cnv4/weights" + string_val: "pose_exp_net/cnv4/biases" + string_val: "pose_exp_net/cnv5/weights" + string_val: "pose_exp_net/cnv5/biases" + string_val: "pose_exp_net/pose/cnv6/weights" + string_val: "pose_exp_net/pose/cnv6/biases" + string_val: "pose_exp_net/pose/cnv7/weights" + string_val: "pose_exp_net/pose/cnv7/biases" + string_val: "pose_exp_net/pose/pred/weights" + string_val: "pose_exp_net/pose/pred/biases" + string_val: "global_step" + string_val: "train_op/beta1_power" + string_val: "train_op/beta2_power" + string_val: "depth_net/cnv1/weights/Adam" + string_val: "depth_net/cnv1/weights/Adam_1" + string_val: "depth_net/cnv1/biases/Adam" + string_val: "depth_net/cnv1/biases/Adam_1" + string_val: "depth_net/cnv1b/weights/Adam" + string_val: "depth_net/cnv1b/weights/Adam_1" + string_val: "depth_net/cnv1b/biases/Adam" + string_val: "depth_net/cnv1b/biases/Adam_1" + string_val: "depth_net/cnv2/weights/Adam" + string_val: "depth_net/cnv2/weights/Adam_1" + string_val: "depth_net/cnv2/biases/Adam" + string_val: "depth_net/cnv2/biases/Adam_1" + string_val: "depth_net/cnv2b/weights/Adam" + string_val: "depth_net/cnv2b/weights/Adam_1" + string_val: "depth_net/cnv2b/biases/Adam" + string_val: "depth_net/cnv2b/biases/Adam_1" + string_val: "depth_net/cnv3/weights/Adam" + string_val: "depth_net/cnv3/weights/Adam_1" + string_val: "depth_net/cnv3/biases/Adam" + string_val: "depth_net/cnv3/biases/Adam_1" + string_val: "depth_net/cnv3b/weights/Adam" + string_val: "depth_net/cnv3b/weights/Adam_1" + string_val: "depth_net/cnv3b/biases/Adam" + string_val: "depth_net/cnv3b/biases/Adam_1" + string_val: "depth_net/cnv4/weights/Adam" + string_val: "depth_net/cnv4/weights/Adam_1" + string_val: "depth_net/cnv4/biases/Adam" + string_val: "depth_net/cnv4/biases/Adam_1" + string_val: "depth_net/cnv4b/weights/Adam" + string_val: "depth_net/cnv4b/weights/Adam_1" + string_val: "depth_net/cnv4b/biases/Adam" + string_val: "depth_net/cnv4b/biases/Adam_1" + string_val: "depth_net/cnv5/weights/Adam" + string_val: "depth_net/cnv5/weights/Adam_1" + string_val: "depth_net/cnv5/biases/Adam" + string_val: "depth_net/cnv5/biases/Adam_1" + string_val: "depth_net/cnv5b/weights/Adam" + string_val: "depth_net/cnv5b/weights/Adam_1" + string_val: "depth_net/cnv5b/biases/Adam" + string_val: "depth_net/cnv5b/biases/Adam_1" + string_val: "depth_net/cnv6/weights/Adam" + string_val: "depth_net/cnv6/weights/Adam_1" + string_val: "depth_net/cnv6/biases/Adam" + string_val: "depth_net/cnv6/biases/Adam_1" + string_val: "depth_net/cnv6b/weights/Adam" + string_val: "depth_net/cnv6b/weights/Adam_1" + string_val: "depth_net/cnv6b/biases/Adam" + string_val: "depth_net/cnv6b/biases/Adam_1" + string_val: "depth_net/cnv7/weights/Adam" + string_val: "depth_net/cnv7/weights/Adam_1" + string_val: "depth_net/cnv7/biases/Adam" + string_val: "depth_net/cnv7/biases/Adam_1" + string_val: "depth_net/cnv7b/weights/Adam" + string_val: "depth_net/cnv7b/weights/Adam_1" + string_val: "depth_net/cnv7b/biases/Adam" + string_val: "depth_net/cnv7b/biases/Adam_1" + string_val: "depth_net/upcnv7/weights/Adam" + string_val: "depth_net/upcnv7/weights/Adam_1" + string_val: "depth_net/upcnv7/biases/Adam" + string_val: "depth_net/upcnv7/biases/Adam_1" + string_val: "depth_net/icnv7/weights/Adam" + string_val: "depth_net/icnv7/weights/Adam_1" + string_val: "depth_net/icnv7/biases/Adam" + string_val: "depth_net/icnv7/biases/Adam_1" + string_val: "depth_net/upcnv6/weights/Adam" + string_val: "depth_net/upcnv6/weights/Adam_1" + string_val: "depth_net/upcnv6/biases/Adam" + string_val: "depth_net/upcnv6/biases/Adam_1" + string_val: "depth_net/icnv6/weights/Adam" + string_val: "depth_net/icnv6/weights/Adam_1" + string_val: "depth_net/icnv6/biases/Adam" + string_val: "depth_net/icnv6/biases/Adam_1" + string_val: "depth_net/upcnv5/weights/Adam" + string_val: "depth_net/upcnv5/weights/Adam_1" + string_val: "depth_net/upcnv5/biases/Adam" + string_val: "depth_net/upcnv5/biases/Adam_1" + string_val: "depth_net/icnv5/weights/Adam" + string_val: "depth_net/icnv5/weights/Adam_1" + string_val: "depth_net/icnv5/biases/Adam" + string_val: "depth_net/icnv5/biases/Adam_1" + string_val: "depth_net/upcnv4/weights/Adam" + string_val: "depth_net/upcnv4/weights/Adam_1" + string_val: "depth_net/upcnv4/biases/Adam" + string_val: "depth_net/upcnv4/biases/Adam_1" + string_val: "depth_net/icnv4/weights/Adam" + string_val: "depth_net/icnv4/weights/Adam_1" + string_val: "depth_net/icnv4/biases/Adam" + string_val: "depth_net/icnv4/biases/Adam_1" + string_val: "depth_net/disp4/weights/Adam" + string_val: "depth_net/disp4/weights/Adam_1" + string_val: "depth_net/disp4/biases/Adam" + string_val: "depth_net/disp4/biases/Adam_1" + string_val: "depth_net/upcnv3/weights/Adam" + string_val: "depth_net/upcnv3/weights/Adam_1" + string_val: "depth_net/upcnv3/biases/Adam" + string_val: "depth_net/upcnv3/biases/Adam_1" + string_val: "depth_net/icnv3/weights/Adam" + string_val: "depth_net/icnv3/weights/Adam_1" + string_val: "depth_net/icnv3/biases/Adam" + string_val: "depth_net/icnv3/biases/Adam_1" + string_val: "depth_net/disp3/weights/Adam" + string_val: "depth_net/disp3/weights/Adam_1" + string_val: "depth_net/disp3/biases/Adam" + string_val: "depth_net/disp3/biases/Adam_1" + string_val: "depth_net/upcnv2/weights/Adam" + string_val: "depth_net/upcnv2/weights/Adam_1" + string_val: "depth_net/upcnv2/biases/Adam" + string_val: "depth_net/upcnv2/biases/Adam_1" + string_val: "depth_net/icnv2/weights/Adam" + string_val: "depth_net/icnv2/weights/Adam_1" + string_val: "depth_net/icnv2/biases/Adam" + string_val: "depth_net/icnv2/biases/Adam_1" + string_val: "depth_net/disp2/weights/Adam" + string_val: "depth_net/disp2/weights/Adam_1" + string_val: "depth_net/disp2/biases/Adam" + string_val: "depth_net/disp2/biases/Adam_1" + string_val: "depth_net/upcnv1/weights/Adam" + string_val: "depth_net/upcnv1/weights/Adam_1" + string_val: "depth_net/upcnv1/biases/Adam" + string_val: "depth_net/upcnv1/biases/Adam_1" + string_val: "depth_net/icnv1/weights/Adam" + string_val: "depth_net/icnv1/weights/Adam_1" + string_val: "depth_net/icnv1/biases/Adam" + string_val: "depth_net/icnv1/biases/Adam_1" + string_val: "depth_net/disp1/weights/Adam" + string_val: "depth_net/disp1/weights/Adam_1" + string_val: "depth_net/disp1/biases/Adam" + string_val: "depth_net/disp1/biases/Adam_1" + string_val: "pose_exp_net/cnv1/weights/Adam" + string_val: "pose_exp_net/cnv1/weights/Adam_1" + string_val: "pose_exp_net/cnv1/biases/Adam" + string_val: "pose_exp_net/cnv1/biases/Adam_1" + string_val: "pose_exp_net/cnv2/weights/Adam" + string_val: "pose_exp_net/cnv2/weights/Adam_1" + string_val: "pose_exp_net/cnv2/biases/Adam" + string_val: "pose_exp_net/cnv2/biases/Adam_1" + string_val: "pose_exp_net/cnv3/weights/Adam" + string_val: "pose_exp_net/cnv3/weights/Adam_1" + string_val: "pose_exp_net/cnv3/biases/Adam" + string_val: "pose_exp_net/cnv3/biases/Adam_1" + string_val: "pose_exp_net/cnv4/weights/Adam" + string_val: "pose_exp_net/cnv4/weights/Adam_1" + string_val: "pose_exp_net/cnv4/biases/Adam" + string_val: "pose_exp_net/cnv4/biases/Adam_1" + string_val: "pose_exp_net/cnv5/weights/Adam" + string_val: "pose_exp_net/cnv5/weights/Adam_1" + string_val: "pose_exp_net/cnv5/biases/Adam" + string_val: "pose_exp_net/cnv5/biases/Adam_1" + string_val: "pose_exp_net/pose/cnv6/weights/Adam" + string_val: "pose_exp_net/pose/cnv6/weights/Adam_1" + string_val: "pose_exp_net/pose/cnv6/biases/Adam" + string_val: "pose_exp_net/pose/cnv6/biases/Adam_1" + string_val: "pose_exp_net/pose/cnv7/weights/Adam" + string_val: "pose_exp_net/pose/cnv7/weights/Adam_1" + string_val: "pose_exp_net/pose/cnv7/biases/Adam" + string_val: "pose_exp_net/pose/cnv7/biases/Adam_1" + string_val: "pose_exp_net/pose/pred/weights/Adam" + string_val: "pose_exp_net/pose/pred/weights/Adam_1" + string_val: "pose_exp_net/pose/pred/biases/Adam" + string_val: "pose_exp_net/pose/pred/biases/Adam_1" + string_val: "train_op/global_step" + } + } + } +} +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: 244 + } + } + } +} +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: 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: "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: 244 + } + } + } +} +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: 0 + } + } + } +} +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: 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/Shape_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: 244 + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/strided_slice_2/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_2/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_2/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_2" + op: "StridedSlice" + input: "report_uninitialized_variables/boolean_mask/Shape_2" + input: "report_uninitialized_variables/boolean_mask/strided_slice_2/stack" + input: "report_uninitialized_variables/boolean_mask/strided_slice_2/stack_1" + input: "report_uninitialized_variables/boolean_mask/strided_slice_2/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_1" + 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/strided_slice_1" + input: "report_uninitialized_variables/boolean_mask/concat/values_1" + input: "report_uninitialized_variables/boolean_mask/strided_slice_2" + input: "report_uninitialized_variables/boolean_mask/concat/axis" + device: "/device:CPU:0" + attr { + key: "N" + value { + i: 3 + } + } + 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: 244 + } + } + } + } + } +} +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: 244 + } + } + } + } + } +} +node { + name: "report_uninitialized_variables/boolean_mask/Where" + op: "Where" + input: "report_uninitialized_variables/boolean_mask/Reshape_1" + device: "/device:CPU:0" + attr { + key: "T" + value { + type: DT_BOOL + } + } + 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/GatherV2/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/GatherV2" + op: "GatherV2" + input: "report_uninitialized_variables/boolean_mask/Reshape" + input: "report_uninitialized_variables/boolean_mask/Squeeze" + input: "report_uninitialized_variables/boolean_mask/GatherV2/axis" + device: "/device:CPU:0" + attr { + key: "Taxis" + value { + type: DT_INT32 + } + } + attr { + key: "Tindices" + value { + type: DT_INT64 + } + } + attr { + key: "Tparams" + value { + type: DT_STRING + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "init" + op: "NoOp" + input: "^depth_net/cnv1/biases/Adam/Assign" + input: "^depth_net/cnv1/biases/Adam_1/Assign" + input: "^depth_net/cnv1/biases/Assign" + input: "^depth_net/cnv1/weights/Adam/Assign" + input: "^depth_net/cnv1/weights/Adam_1/Assign" + input: "^depth_net/cnv1/weights/Assign" + input: "^depth_net/cnv1b/biases/Adam/Assign" + input: "^depth_net/cnv1b/biases/Adam_1/Assign" + input: "^depth_net/cnv1b/biases/Assign" + input: "^depth_net/cnv1b/weights/Adam/Assign" + input: "^depth_net/cnv1b/weights/Adam_1/Assign" + input: "^depth_net/cnv1b/weights/Assign" + input: "^depth_net/cnv2/biases/Adam/Assign" + input: "^depth_net/cnv2/biases/Adam_1/Assign" + input: "^depth_net/cnv2/biases/Assign" + input: "^depth_net/cnv2/weights/Adam/Assign" + input: "^depth_net/cnv2/weights/Adam_1/Assign" + input: "^depth_net/cnv2/weights/Assign" + input: "^depth_net/cnv2b/biases/Adam/Assign" + input: "^depth_net/cnv2b/biases/Adam_1/Assign" + input: "^depth_net/cnv2b/biases/Assign" + input: "^depth_net/cnv2b/weights/Adam/Assign" + input: "^depth_net/cnv2b/weights/Adam_1/Assign" + input: "^depth_net/cnv2b/weights/Assign" + input: "^depth_net/cnv3/biases/Adam/Assign" + input: "^depth_net/cnv3/biases/Adam_1/Assign" + input: "^depth_net/cnv3/biases/Assign" + input: "^depth_net/cnv3/weights/Adam/Assign" + input: "^depth_net/cnv3/weights/Adam_1/Assign" + input: "^depth_net/cnv3/weights/Assign" + input: "^depth_net/cnv3b/biases/Adam/Assign" + input: "^depth_net/cnv3b/biases/Adam_1/Assign" + input: "^depth_net/cnv3b/biases/Assign" + input: "^depth_net/cnv3b/weights/Adam/Assign" + input: "^depth_net/cnv3b/weights/Adam_1/Assign" + input: "^depth_net/cnv3b/weights/Assign" + input: "^depth_net/cnv4/biases/Adam/Assign" + input: "^depth_net/cnv4/biases/Adam_1/Assign" + input: "^depth_net/cnv4/biases/Assign" + input: "^depth_net/cnv4/weights/Adam/Assign" + input: "^depth_net/cnv4/weights/Adam_1/Assign" + input: "^depth_net/cnv4/weights/Assign" + input: "^depth_net/cnv4b/biases/Adam/Assign" + input: "^depth_net/cnv4b/biases/Adam_1/Assign" + input: "^depth_net/cnv4b/biases/Assign" + input: "^depth_net/cnv4b/weights/Adam/Assign" + input: "^depth_net/cnv4b/weights/Adam_1/Assign" + input: "^depth_net/cnv4b/weights/Assign" + input: "^depth_net/cnv5/biases/Adam/Assign" + input: "^depth_net/cnv5/biases/Adam_1/Assign" + input: "^depth_net/cnv5/biases/Assign" + input: "^depth_net/cnv5/weights/Adam/Assign" + input: "^depth_net/cnv5/weights/Adam_1/Assign" + input: "^depth_net/cnv5/weights/Assign" + input: "^depth_net/cnv5b/biases/Adam/Assign" + input: "^depth_net/cnv5b/biases/Adam_1/Assign" + input: "^depth_net/cnv5b/biases/Assign" + input: "^depth_net/cnv5b/weights/Adam/Assign" + input: "^depth_net/cnv5b/weights/Adam_1/Assign" + input: "^depth_net/cnv5b/weights/Assign" + input: "^depth_net/cnv6/biases/Adam/Assign" + input: "^depth_net/cnv6/biases/Adam_1/Assign" + input: "^depth_net/cnv6/biases/Assign" + input: "^depth_net/cnv6/weights/Adam/Assign" + input: "^depth_net/cnv6/weights/Adam_1/Assign" + input: "^depth_net/cnv6/weights/Assign" + input: "^depth_net/cnv6b/biases/Adam/Assign" + input: "^depth_net/cnv6b/biases/Adam_1/Assign" + input: "^depth_net/cnv6b/biases/Assign" + input: "^depth_net/cnv6b/weights/Adam/Assign" + input: "^depth_net/cnv6b/weights/Adam_1/Assign" + input: "^depth_net/cnv6b/weights/Assign" + input: "^depth_net/cnv7/biases/Adam/Assign" + input: "^depth_net/cnv7/biases/Adam_1/Assign" + input: "^depth_net/cnv7/biases/Assign" + input: "^depth_net/cnv7/weights/Adam/Assign" + input: "^depth_net/cnv7/weights/Adam_1/Assign" + input: "^depth_net/cnv7/weights/Assign" + input: "^depth_net/cnv7b/biases/Adam/Assign" + input: "^depth_net/cnv7b/biases/Adam_1/Assign" + input: "^depth_net/cnv7b/biases/Assign" + input: "^depth_net/cnv7b/weights/Adam/Assign" + input: "^depth_net/cnv7b/weights/Adam_1/Assign" + input: "^depth_net/cnv7b/weights/Assign" + input: "^depth_net/disp1/biases/Adam/Assign" + input: "^depth_net/disp1/biases/Adam_1/Assign" + input: "^depth_net/disp1/biases/Assign" + input: "^depth_net/disp1/weights/Adam/Assign" + input: "^depth_net/disp1/weights/Adam_1/Assign" + input: "^depth_net/disp1/weights/Assign" + input: "^depth_net/disp2/biases/Adam/Assign" + input: "^depth_net/disp2/biases/Adam_1/Assign" + input: "^depth_net/disp2/biases/Assign" + input: "^depth_net/disp2/weights/Adam/Assign" + input: "^depth_net/disp2/weights/Adam_1/Assign" + input: "^depth_net/disp2/weights/Assign" + input: "^depth_net/disp3/biases/Adam/Assign" + input: "^depth_net/disp3/biases/Adam_1/Assign" + input: "^depth_net/disp3/biases/Assign" + input: "^depth_net/disp3/weights/Adam/Assign" + input: "^depth_net/disp3/weights/Adam_1/Assign" + input: "^depth_net/disp3/weights/Assign" + input: "^depth_net/disp4/biases/Adam/Assign" + input: "^depth_net/disp4/biases/Adam_1/Assign" + input: "^depth_net/disp4/biases/Assign" + input: "^depth_net/disp4/weights/Adam/Assign" + input: "^depth_net/disp4/weights/Adam_1/Assign" + input: "^depth_net/disp4/weights/Assign" + input: "^depth_net/icnv1/biases/Adam/Assign" + input: "^depth_net/icnv1/biases/Adam_1/Assign" + input: "^depth_net/icnv1/biases/Assign" + input: "^depth_net/icnv1/weights/Adam/Assign" + input: "^depth_net/icnv1/weights/Adam_1/Assign" + input: "^depth_net/icnv1/weights/Assign" + input: "^depth_net/icnv2/biases/Adam/Assign" + input: "^depth_net/icnv2/biases/Adam_1/Assign" + input: "^depth_net/icnv2/biases/Assign" + input: "^depth_net/icnv2/weights/Adam/Assign" + input: "^depth_net/icnv2/weights/Adam_1/Assign" + input: "^depth_net/icnv2/weights/Assign" + input: "^depth_net/icnv3/biases/Adam/Assign" + input: "^depth_net/icnv3/biases/Adam_1/Assign" + input: "^depth_net/icnv3/biases/Assign" + input: "^depth_net/icnv3/weights/Adam/Assign" + input: "^depth_net/icnv3/weights/Adam_1/Assign" + input: "^depth_net/icnv3/weights/Assign" + input: "^depth_net/icnv4/biases/Adam/Assign" + input: "^depth_net/icnv4/biases/Adam_1/Assign" + input: "^depth_net/icnv4/biases/Assign" + input: "^depth_net/icnv4/weights/Adam/Assign" + input: "^depth_net/icnv4/weights/Adam_1/Assign" + input: "^depth_net/icnv4/weights/Assign" + input: "^depth_net/icnv5/biases/Adam/Assign" + input: "^depth_net/icnv5/biases/Adam_1/Assign" + input: "^depth_net/icnv5/biases/Assign" + input: "^depth_net/icnv5/weights/Adam/Assign" + input: "^depth_net/icnv5/weights/Adam_1/Assign" + input: "^depth_net/icnv5/weights/Assign" + input: "^depth_net/icnv6/biases/Adam/Assign" + input: "^depth_net/icnv6/biases/Adam_1/Assign" + input: "^depth_net/icnv6/biases/Assign" + input: "^depth_net/icnv6/weights/Adam/Assign" + input: "^depth_net/icnv6/weights/Adam_1/Assign" + input: "^depth_net/icnv6/weights/Assign" + input: "^depth_net/icnv7/biases/Adam/Assign" + input: "^depth_net/icnv7/biases/Adam_1/Assign" + input: "^depth_net/icnv7/biases/Assign" + input: "^depth_net/icnv7/weights/Adam/Assign" + input: "^depth_net/icnv7/weights/Adam_1/Assign" + input: "^depth_net/icnv7/weights/Assign" + input: "^depth_net/upcnv1/biases/Adam/Assign" + input: "^depth_net/upcnv1/biases/Adam_1/Assign" + input: "^depth_net/upcnv1/biases/Assign" + input: "^depth_net/upcnv1/weights/Adam/Assign" + input: "^depth_net/upcnv1/weights/Adam_1/Assign" + input: "^depth_net/upcnv1/weights/Assign" + input: "^depth_net/upcnv2/biases/Adam/Assign" + input: "^depth_net/upcnv2/biases/Adam_1/Assign" + input: "^depth_net/upcnv2/biases/Assign" + input: "^depth_net/upcnv2/weights/Adam/Assign" + input: "^depth_net/upcnv2/weights/Adam_1/Assign" + input: "^depth_net/upcnv2/weights/Assign" + input: "^depth_net/upcnv3/biases/Adam/Assign" + input: "^depth_net/upcnv3/biases/Adam_1/Assign" + input: "^depth_net/upcnv3/biases/Assign" + input: "^depth_net/upcnv3/weights/Adam/Assign" + input: "^depth_net/upcnv3/weights/Adam_1/Assign" + input: "^depth_net/upcnv3/weights/Assign" + input: "^depth_net/upcnv4/biases/Adam/Assign" + input: "^depth_net/upcnv4/biases/Adam_1/Assign" + input: "^depth_net/upcnv4/biases/Assign" + input: "^depth_net/upcnv4/weights/Adam/Assign" + input: "^depth_net/upcnv4/weights/Adam_1/Assign" + input: "^depth_net/upcnv4/weights/Assign" + input: "^depth_net/upcnv5/biases/Adam/Assign" + input: "^depth_net/upcnv5/biases/Adam_1/Assign" + input: "^depth_net/upcnv5/biases/Assign" + input: "^depth_net/upcnv5/weights/Adam/Assign" + input: "^depth_net/upcnv5/weights/Adam_1/Assign" + input: "^depth_net/upcnv5/weights/Assign" + input: "^depth_net/upcnv6/biases/Adam/Assign" + input: "^depth_net/upcnv6/biases/Adam_1/Assign" + input: "^depth_net/upcnv6/biases/Assign" + input: "^depth_net/upcnv6/weights/Adam/Assign" + input: "^depth_net/upcnv6/weights/Adam_1/Assign" + input: "^depth_net/upcnv6/weights/Assign" + input: "^depth_net/upcnv7/biases/Adam/Assign" + input: "^depth_net/upcnv7/biases/Adam_1/Assign" + input: "^depth_net/upcnv7/biases/Assign" + input: "^depth_net/upcnv7/weights/Adam/Assign" + input: "^depth_net/upcnv7/weights/Adam_1/Assign" + input: "^depth_net/upcnv7/weights/Assign" + input: "^global_step/Assign" + input: "^pose_exp_net/cnv1/biases/Adam/Assign" + input: "^pose_exp_net/cnv1/biases/Adam_1/Assign" + input: "^pose_exp_net/cnv1/biases/Assign" + input: "^pose_exp_net/cnv1/weights/Adam/Assign" + input: "^pose_exp_net/cnv1/weights/Adam_1/Assign" + input: "^pose_exp_net/cnv1/weights/Assign" + input: "^pose_exp_net/cnv2/biases/Adam/Assign" + input: "^pose_exp_net/cnv2/biases/Adam_1/Assign" + input: "^pose_exp_net/cnv2/biases/Assign" + input: "^pose_exp_net/cnv2/weights/Adam/Assign" + input: "^pose_exp_net/cnv2/weights/Adam_1/Assign" + input: "^pose_exp_net/cnv2/weights/Assign" + input: "^pose_exp_net/cnv3/biases/Adam/Assign" + input: "^pose_exp_net/cnv3/biases/Adam_1/Assign" + input: "^pose_exp_net/cnv3/biases/Assign" + input: "^pose_exp_net/cnv3/weights/Adam/Assign" + input: "^pose_exp_net/cnv3/weights/Adam_1/Assign" + input: "^pose_exp_net/cnv3/weights/Assign" + input: "^pose_exp_net/cnv4/biases/Adam/Assign" + input: "^pose_exp_net/cnv4/biases/Adam_1/Assign" + input: "^pose_exp_net/cnv4/biases/Assign" + input: "^pose_exp_net/cnv4/weights/Adam/Assign" + input: "^pose_exp_net/cnv4/weights/Adam_1/Assign" + input: "^pose_exp_net/cnv4/weights/Assign" + input: "^pose_exp_net/cnv5/biases/Adam/Assign" + input: "^pose_exp_net/cnv5/biases/Adam_1/Assign" + input: "^pose_exp_net/cnv5/biases/Assign" + input: "^pose_exp_net/cnv5/weights/Adam/Assign" + input: "^pose_exp_net/cnv5/weights/Adam_1/Assign" + input: "^pose_exp_net/cnv5/weights/Assign" + input: "^pose_exp_net/pose/cnv6/biases/Adam/Assign" + input: "^pose_exp_net/pose/cnv6/biases/Adam_1/Assign" + input: "^pose_exp_net/pose/cnv6/biases/Assign" + input: "^pose_exp_net/pose/cnv6/weights/Adam/Assign" + input: "^pose_exp_net/pose/cnv6/weights/Adam_1/Assign" + input: "^pose_exp_net/pose/cnv6/weights/Assign" + input: "^pose_exp_net/pose/cnv7/biases/Adam/Assign" + input: "^pose_exp_net/pose/cnv7/biases/Adam_1/Assign" + input: "^pose_exp_net/pose/cnv7/biases/Assign" + input: "^pose_exp_net/pose/cnv7/weights/Adam/Assign" + input: "^pose_exp_net/pose/cnv7/weights/Adam_1/Assign" + input: "^pose_exp_net/pose/cnv7/weights/Assign" + input: "^pose_exp_net/pose/pred/biases/Adam/Assign" + input: "^pose_exp_net/pose/pred/biases/Adam_1/Assign" + input: "^pose_exp_net/pose/pred/biases/Assign" + input: "^pose_exp_net/pose/pred/weights/Adam/Assign" + input: "^pose_exp_net/pose/pred/weights/Adam_1/Assign" + input: "^pose_exp_net/pose/pred/weights/Assign" + input: "^train_op/beta1_power/Assign" + input: "^train_op/beta2_power/Assign" + input: "^train_op/global_step/Assign" +} +node { + name: "init_1" + op: "NoOp" +} +node { + name: "init_all_tables" + op: "NoOp" +} +node { + name: "group_deps" + op: "NoOp" + input: "^init_1" + input: "^init_all_tables" +} +node { + name: "Merge/MergeSummary" + op: "MergeSummary" + input: "data_loading/input_producer/fraction_of_32_full" + input: "data_loading/input_producer_1/fraction_of_32_full" + input: "data_loading/batch/fraction_of_32_full" + input: "total_loss" + input: "pixel_loss" + input: "smooth_loss" + input: "exp_loss" + input: "scale0_depth" + input: "scale0_disparity_image" + input: "scale0_target_image" + input: "scale0_source_image_0" + input: "scale0_projected_image_0" + input: "scale0_proj_error_0" + input: "scale0_source_image_1" + input: "scale0_projected_image_1" + input: "scale0_proj_error_1" + input: "scale1_depth" + input: "scale1_disparity_image" + input: "scale1_target_image" + input: "scale1_source_image_0" + input: "scale1_projected_image_0" + input: "scale1_proj_error_0" + input: "scale1_source_image_1" + input: "scale1_projected_image_1" + input: "scale1_proj_error_1" + input: "scale2_depth" + input: "scale2_disparity_image" + input: "scale2_target_image" + input: "scale2_source_image_0" + input: "scale2_projected_image_0" + input: "scale2_proj_error_0" + input: "scale2_source_image_1" + input: "scale2_projected_image_1" + input: "scale2_proj_error_1" + input: "scale3_depth" + input: "scale3_disparity_image" + input: "scale3_target_image" + input: "scale3_source_image_0" + input: "scale3_projected_image_0" + input: "scale3_proj_error_0" + input: "scale3_source_image_1" + input: "scale3_projected_image_1" + input: "scale3_proj_error_1" + input: "tx" + input: "ty" + input: "tz" + input: "rx" + input: "ry" + input: "rz" + attr { + key: "N" + value { + i: 49 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +versions { + producer: 26 +} diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/__init__.py b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/__pycache__/__init__.cpython-36.pyc b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/__pycache__/__init__.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b1cb5dffab6f834a34179fac587612ea2496a236 Binary files /dev/null and b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/__pycache__/__init__.cpython-36.pyc differ diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/__pycache__/depth_evaluation_utils.cpython-36.pyc b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/__pycache__/depth_evaluation_utils.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5e83550dc648afa518107600e39b2f0d0036b735 Binary files /dev/null and b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/__pycache__/depth_evaluation_utils.cpython-36.pyc differ diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/__pycache__/pose_evaluation_utils.cpython-36.pyc b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/__pycache__/pose_evaluation_utils.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..696bd2ee766641f041ccf189379e2ab80e6cb908 Binary files /dev/null and b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/__pycache__/pose_evaluation_utils.cpython-36.pyc differ diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/depth_evaluation_utils.py b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/depth_evaluation_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..2f154a19bbfef520f2d719c692adfee4d01dadee --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/depth_evaluation_utils.py @@ -0,0 +1,226 @@ +# Mostly based on the code written by Clement Godard: +# https://github.com/mrharicot/monodepth/blob/master/utils/evaluation_utils.py +import numpy as np +# import pandas as pd +import os +import cv2 +from collections import Counter +import pickle + +def compute_errors(gt, pred): + thresh = np.maximum((gt / pred), (pred / gt)) + a1 = (thresh < 1.25 ).mean() + a2 = (thresh < 1.25 ** 2).mean() + a3 = (thresh < 1.25 ** 3).mean() + + rmse = (gt - pred) ** 2 + rmse = np.sqrt(rmse.mean()) + + rmse_log = (np.log(gt) - np.log(pred)) ** 2 + rmse_log = np.sqrt(rmse_log.mean()) + + abs_rel = np.mean(np.abs(gt - pred) / gt) + + sq_rel = np.mean(((gt - pred)**2) / gt) + + return abs_rel, sq_rel, rmse, rmse_log, a1, a2, a3 + +############################################################################### +####################### KITTI + +width_to_focal = dict() +width_to_focal[1242] = 721.5377 +width_to_focal[1241] = 718.856 +width_to_focal[1224] = 707.0493 +width_to_focal[1238] = 718.3351 + +def load_gt_disp_kitti(path): + gt_disparities = [] + for i in range(200): + disp = cv2.imread(path + "/training/disp_noc_0/" + str(i).zfill(6) + "_10.png", -1) + disp = disp.astype(np.float32) / 256 + gt_disparities.append(disp) + return gt_disparities + +def convert_disps_to_depths_kitti(gt_disparities, pred_disparities): + gt_depths = [] + pred_depths = [] + pred_disparities_resized = [] + + for i in range(len(gt_disparities)): + gt_disp = gt_disparities[i] + height, width = gt_disp.shape + + pred_disp = pred_disparities[i] + pred_disp = width * cv2.resize(pred_disp, (width, height), interpolation=cv2.INTER_LINEAR) + + pred_disparities_resized.append(pred_disp) + + mask = gt_disp > 0 + + gt_depth = width_to_focal[width] * 0.54 / (gt_disp + (1.0 - mask)) + pred_depth = width_to_focal[width] * 0.54 / pred_disp + + gt_depths.append(gt_depth) + pred_depths.append(pred_depth) + return gt_depths, pred_depths, pred_disparities_resized + + +############################################################################### +####################### EIGEN + +def read_text_lines(file_path): + f = open(file_path, 'r') + lines = f.readlines() + f.close() + lines = [l.rstrip() for l in lines] + return lines + +def read_file_data(files, data_root): + gt_files = [] + gt_calib = [] + im_sizes = [] + im_files = [] + cams = [] + num_probs = 0 + for filename in files: + filename = filename.split()[0] + splits = filename.split('/') +# camera_id = filename[-1] # 2 is left, 3 is right + date = splits[0] + im_id = splits[4][:10] + file_root = '{}/{}' + + im = filename + vel = '{}/{}/velodyne_points/data/{}.bin'.format(splits[0], splits[1], im_id) + + if os.path.isfile(data_root + im): + gt_files.append(data_root + vel) + gt_calib.append(data_root + date + '/') + im_sizes.append(cv2.imread(data_root + im).shape[:2]) + im_files.append(data_root + im) + cams.append(2) + else: + num_probs += 1 + print('{} missing'.format(data_root + im)) + # print(num_probs, 'files missing') + + return gt_files, gt_calib, im_sizes, im_files, cams + +def load_velodyne_points(file_name): + # adapted from https://github.com/hunse/kitti + points = np.fromfile(file_name, dtype=np.float32).reshape(-1, 4) + points[:, 3] = 1.0 # homogeneous + return points + + +def lin_interp(shape, xyd): + # taken from https://github.com/hunse/kitti + m, n = shape + ij, d = xyd[:, 1::-1], xyd[:, 2] + f = LinearNDInterpolator(ij, d, fill_value=0) + J, I = np.meshgrid(np.arange(n), np.arange(m)) + IJ = np.vstack([I.flatten(), J.flatten()]).T + disparity = f(IJ).reshape(shape) + return disparity + + +def read_calib_file(path): + # taken from https://github.com/hunse/kitti + float_chars = set("0123456789.e+- ") + data = {} + with open(path, 'r') as f: + for line in f.readlines(): + key, value = line.split(':', 1) + value = value.strip() + data[key] = value + if float_chars.issuperset(value): + # try to cast to float array + try: + data[key] = np.array(map(float, value.split(' '))) + except ValueError: + # casting error: data[key] already eq. value, so pass + pass + + return data + + +def get_focal_length_baseline(calib_dir, cam=2): + cam2cam = read_calib_file(calib_dir + 'calib_cam_to_cam.txt') + P2_rect = cam2cam['P_rect_02'].reshape(3,4) + P3_rect = cam2cam['P_rect_03'].reshape(3,4) + + # cam 2 is left of camera 0 -6cm + # cam 3 is to the right +54cm + b2 = P2_rect[0,3] / -P2_rect[0,0] + b3 = P3_rect[0,3] / -P3_rect[0,0] + baseline = b3-b2 + + if cam==2: + focal_length = P2_rect[0,0] + elif cam==3: + focal_length = P3_rect[0,0] + + return focal_length, baseline + + +def sub2ind(matrixSize, rowSub, colSub): + m, n = matrixSize + return rowSub * (n-1) + colSub - 1 + +def generate_depth_map(calib_dir, velo_file_name, im_shape, cam=2, interp=False, vel_depth=False): + # load calibration files + cam2cam = read_calib_file(calib_dir + 'calib_cam_to_cam.txt') + velo2cam = read_calib_file(calib_dir + 'calib_velo_to_cam.txt') + velo2cam = np.hstack((velo2cam['R'].reshape(3,3), velo2cam['T'][..., np.newaxis])) + velo2cam = np.vstack((velo2cam, np.array([0, 0, 0, 1.0]))) + + # compute projection matrix velodyne->image plane + R_cam2rect = np.eye(4) + R_cam2rect[:3,:3] = cam2cam['R_rect_00'].reshape(3,3) + P_rect = cam2cam['P_rect_0'+str(cam)].reshape(3,4) + P_velo2im = np.dot(np.dot(P_rect, R_cam2rect), velo2cam) + + # load velodyne points and remove all behind image plane (approximation) + # each row of the velodyne data is forward, left, up, reflectance + velo = load_velodyne_points(velo_file_name) + velo = velo[velo[:, 0] >= 0, :] + + # project the points to the camera + velo_pts_im = np.dot(P_velo2im, velo.T).T + velo_pts_im[:, :2] = velo_pts_im[:,:2] / velo_pts_im[:,2][..., np.newaxis] + + if vel_depth: + velo_pts_im[:, 2] = velo[:, 0] + + # check if in bounds + # use minus 1 to get the exact same value as KITTI matlab code + velo_pts_im[:, 0] = np.round(velo_pts_im[:,0]) - 1 + velo_pts_im[:, 1] = np.round(velo_pts_im[:,1]) - 1 + val_inds = (velo_pts_im[:, 0] >= 0) & (velo_pts_im[:, 1] >= 0) + val_inds = val_inds & (velo_pts_im[:,0] < im_shape[1]) & (velo_pts_im[:,1] < im_shape[0]) + velo_pts_im = velo_pts_im[val_inds, :] + + # project to image + depth = np.zeros((im_shape)) + depth[velo_pts_im[:, 1].astype(np.int), velo_pts_im[:, 0].astype(np.int)] = velo_pts_im[:, 2] + + # find the duplicate points and choose the closest depth + inds = sub2ind(depth.shape, velo_pts_im[:, 1], velo_pts_im[:, 0]) + dupe_inds = [item for item, count in Counter(inds).iteritems() if count > 1] + for dd in dupe_inds: + pts = np.where(inds==dd)[0] + x_loc = int(velo_pts_im[pts[0], 0]) + y_loc = int(velo_pts_im[pts[0], 1]) + depth[y_loc, x_loc] = velo_pts_im[pts, 2].min() + depth[depth<0] = 0 + + if interp: + # interpolate the depth map to fill in holes + depth_interp = lin_interp(im_shape, velo_pts_im) + return depth, depth_interp + else: + return depth + + + diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/eval_depth.py b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/eval_depth.py new file mode 100644 index 0000000000000000000000000000000000000000..9cc3ea9a96a9ec86562da9cc71c9270369f86836 --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/eval_depth.py @@ -0,0 +1,77 @@ +from __future__ import division +import sys +import cv2 +import os +import numpy as np +import argparse +from depth_evaluation_utils import * + +parser = argparse.ArgumentParser() +parser.add_argument("--kitti_dir", type=str, help='Path to the KITTI dataset directory') +parser.add_argument("--pred_file", type=str, help="Path to the prediction file") +parser.add_argument("--test_file_list", type=str, default='./data/kitti/test_files_eigen.txt', + help="Path to the list of test files") +parser.add_argument('--min_depth', type=float, default=1e-3, help="Threshold for minimum depth") +parser.add_argument('--max_depth', type=float, default=80, help="Threshold for maximum depth") +args = parser.parse_args() + +def main(): + pred_depths = np.load(args.pred_file) + test_files = read_text_lines(args.test_file_list) + gt_files, gt_calib, im_sizes, im_files, cams = \ + read_file_data(test_files, args.kitti_dir) + num_test = len(im_files) + gt_depths = [] + pred_depths_resized = [] + for t_id in range(num_test): + camera_id = cams[t_id] # 2 is left, 3 is right + pred_depths_resized.append( + cv2.resize(pred_depths[t_id], + (im_sizes[t_id][1], im_sizes[t_id][0]), + interpolation=cv2.INTER_LINEAR)) + depth = generate_depth_map(gt_calib[t_id], + gt_files[t_id], + im_sizes[t_id], + camera_id, + False, + True) + gt_depths.append(depth.astype(np.float32)) + pred_depths = pred_depths_resized + + rms = np.zeros(num_test, np.float32) + log_rms = np.zeros(num_test, np.float32) + abs_rel = np.zeros(num_test, np.float32) + sq_rel = np.zeros(num_test, np.float32) + d1_all = np.zeros(num_test, np.float32) + a1 = np.zeros(num_test, np.float32) + a2 = np.zeros(num_test, np.float32) + a3 = np.zeros(num_test, np.float32) + for i in range(num_test): + gt_depth = gt_depths[i] + pred_depth = np.copy(pred_depths[i]) + + mask = np.logical_and(gt_depth > args.min_depth, + gt_depth < args.max_depth) + # crop used by Garg ECCV16 to reprocude Eigen NIPS14 results + # if used on gt_size 370x1224 produces a crop of [-218, -3, 44, 1180] + gt_height, gt_width = gt_depth.shape + crop = np.array([0.40810811 * gt_height, 0.99189189 * gt_height, + 0.03594771 * gt_width, 0.96405229 * gt_width]).astype(np.int32) + + crop_mask = np.zeros(mask.shape) + crop_mask[crop[0]:crop[1],crop[2]:crop[3]] = 1 + mask = np.logical_and(mask, crop_mask) + + # Scale matching + scalor = np.median(gt_depth[mask])/np.median(pred_depth[mask]) + pred_depth[mask] *= scalor + + pred_depth[pred_depth < args.min_depth] = args.min_depth + pred_depth[pred_depth > args.max_depth] = args.max_depth + abs_rel[i], sq_rel[i], rms[i], log_rms[i], a1[i], a2[i], a3[i] = \ + compute_errors(gt_depth[mask], pred_depth[mask]) + + print("{:>10}, {:>10}, {:>10}, {:>10}, {:>10}, {:>10}, {:>10}, {:>10}".format('abs_rel', 'sq_rel', 'rms', 'log_rms', 'd1_all', 'a1', 'a2', 'a3')) + print("{:10.4f}, {:10.4f}, {:10.4f}, {:10.4f}, {:10.4f}, {:10.4f}, {:10.4f}, {:10.4f}".format(abs_rel.mean(), sq_rel.mean(), rms.mean(), log_rms.mean(), d1_all.mean(), a1.mean(), a2.mean(), a3.mean())) + +main() diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/eval_pose.py b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/eval_pose.py new file mode 100644 index 0000000000000000000000000000000000000000..780ee999f9ab2344b0beaf993550848264401eb1 --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/eval_pose.py @@ -0,0 +1,29 @@ +from __future__ import division +import os +import numpy as np +import argparse +from glob import glob +from pose_evaluation_utils import * + +parser = argparse.ArgumentParser() +parser.add_argument("--gtruth_dir", type=str, + help='Path to the directory with ground-truth trajectories') +parser.add_argument("--pred_dir", type=str, + help="Path to the directory with predicted trajectories") +args = parser.parse_args() + +def main(): + pred_files = glob(args.pred_dir + '/*.txt') + ate_all = [] + for i in range(len(pred_files)): + gtruth_file = args.gtruth_dir + os.path.basename(pred_files[i]) + if not os.path.exists(gtruth_file): + continue + ate = compute_ate(gtruth_file, pred_files[i]) + if ate == False: + continue + ate_all.append(ate) + ate_all = np.array(ate_all) + print("Predictions dir: %s" % args.pred_dir) + print("ATE mean: %.4f, std: %.4f" % (np.mean(ate_all), np.std(ate_all))) +main() \ No newline at end of file diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/pose_evaluation_utils.py b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/pose_evaluation_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..7ec10dbcdabfb6c9cc0a04bb61c60f16e8806bde --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/kitti_eval/pose_evaluation_utils.py @@ -0,0 +1,383 @@ +# Some of the code are from the TUM evaluation toolkit: +# https://vision.in.tum.de/data/datasets/rgbd-dataset/tools#absolute_trajectory_error_ate + +import math +import numpy as np + +def compute_ate(gtruth_file, pred_file): + gtruth_list = read_file_list(gtruth_file) + pred_list = read_file_list(pred_file) + matches = associate(gtruth_list, pred_list, 0, 0.01) + if len(matches) < 2: + return False + + gtruth_xyz = np.array([[float(value) for value in gtruth_list[a][0:3]] for a,b in matches]) + pred_xyz = np.array([[float(value) for value in pred_list[b][0:3]] for a,b in matches]) + + # Make sure that the first matched frames align (no need for rotational alignment as + # all the predicted/ground-truth snippets have been converted to use the same coordinate + # system with the first frame of the snippet being the origin). + offset = gtruth_xyz[0] - pred_xyz[0] + pred_xyz += offset[None,:] + + # Optimize the scaling factor + scale = np.sum(gtruth_xyz * pred_xyz)/np.sum(pred_xyz ** 2) + alignment_error = pred_xyz * scale - gtruth_xyz + rmse = np.sqrt(np.sum(alignment_error ** 2))/len(matches) + return rmse + +def read_file_list(filename): + """ + Reads a trajectory from a text file. + + File format: + The file format is "stamp d1 d2 d3 ...", where stamp denotes the time stamp (to be matched) + and "d1 d2 d3.." is arbitary data (e.g., a 3D position and 3D orientation) associated to this timestamp. + + Input: + filename -- File name + + Output: + dict -- dictionary of (stamp,data) tuples + + """ + file = open(filename) + data = file.read() + lines = data.replace(","," ").replace("\t"," ").split("\n") + list = [[v.strip() for v in line.split(" ") if v.strip()!=""] for line in lines if len(line)>0 and line[0]!="#"] + list = [(float(l[0]),l[1:]) for l in list if len(l)>1] + return dict(list) + +def associate(first_list, second_list,offset,max_difference): + """ + Associate two dictionaries of (stamp,data). As the time stamps never match exactly, we aim + to find the closest match for every input tuple. + + Input: + first_list -- first dictionary of (stamp,data) tuples + second_list -- second dictionary of (stamp,data) tuples + offset -- time offset between both dictionaries (e.g., to model the delay between the sensors) + max_difference -- search radius for candidate generation + + Output: + matches -- list of matched tuples ((stamp1,data1),(stamp2,data2)) + + """ + first_keys = list(first_list.keys()) + second_keys = list(second_list.keys()) + potential_matches = [(abs(a - (b + offset)), a, b) + for a in first_keys + for b in second_keys + if abs(a - (b + offset)) < max_difference] + potential_matches.sort() + matches = [] + for diff, a, b in potential_matches: + if a in first_keys and b in second_keys: + first_keys.remove(a) + second_keys.remove(b) + matches.append((a, b)) + + matches.sort() + return matches + +def rot2quat(R): + rz, ry, rx = mat2euler(R) + qw, qx, qy, qz = euler2quat(rz, ry, rx) + return qw, qx, qy, qz + +def quat2mat(q): + ''' Calculate rotation matrix corresponding to quaternion + https://afni.nimh.nih.gov/pub/dist/src/pkundu/meica.libs/nibabel/quaternions.py + Parameters + ---------- + q : 4 element array-like + + Returns + ------- + M : (3,3) array + Rotation matrix corresponding to input quaternion *q* + + Notes + ----- + Rotation matrix applies to column vectors, and is applied to the + left of coordinate vectors. The algorithm here allows non-unit + quaternions. + + References + ---------- + Algorithm from + http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion + + Examples + -------- + >>> import numpy as np + >>> M = quat2mat([1, 0, 0, 0]) # Identity quaternion + >>> np.allclose(M, np.eye(3)) + True + >>> M = quat2mat([0, 1, 0, 0]) # 180 degree rotn around axis 0 + >>> np.allclose(M, np.diag([1, -1, -1])) + True + ''' + w, x, y, z = q + Nq = w*w + x*x + y*y + z*z + if Nq < 1e-8: + return np.eye(3) + s = 2.0/Nq + X = x*s + Y = y*s + Z = z*s + wX = w*X; wY = w*Y; wZ = w*Z + xX = x*X; xY = x*Y; xZ = x*Z + yY = y*Y; yZ = y*Z; zZ = z*Z + return np.array( + [[ 1.0-(yY+zZ), xY-wZ, xZ+wY ], + [ xY+wZ, 1.0-(xX+zZ), yZ-wX ], + [ xZ-wY, yZ+wX, 1.0-(xX+yY) ]]) + +def mat2euler(M, cy_thresh=None, seq='zyx'): + ''' + Taken From: http://afni.nimh.nih.gov/pub/dist/src/pkundu/meica.libs/nibabel/eulerangles.py + Discover Euler angle vector from 3x3 matrix + Uses the conventions above. + Parameters + ---------- + M : array-like, shape (3,3) + cy_thresh : None or scalar, optional + threshold below which to give up on straightforward arctan for + estimating x rotation. If None (default), estimate from + precision of input. + Returns + ------- + z : scalar + y : scalar + x : scalar + Rotations in radians around z, y, x axes, respectively + Notes + ----- + If there was no numerical error, the routine could be derived using + Sympy expression for z then y then x rotation matrix, which is:: + [ cos(y)*cos(z), -cos(y)*sin(z), sin(y)], + [cos(x)*sin(z) + cos(z)*sin(x)*sin(y), cos(x)*cos(z) - sin(x)*sin(y)*sin(z), -cos(y)*sin(x)], + [sin(x)*sin(z) - cos(x)*cos(z)*sin(y), cos(z)*sin(x) + cos(x)*sin(y)*sin(z), cos(x)*cos(y)] + with the obvious derivations for z, y, and x + z = atan2(-r12, r11) + y = asin(r13) + x = atan2(-r23, r33) + for x,y,z order + y = asin(-r31) + x = atan2(r32, r33) + z = atan2(r21, r11) + Problems arise when cos(y) is close to zero, because both of:: + z = atan2(cos(y)*sin(z), cos(y)*cos(z)) + x = atan2(cos(y)*sin(x), cos(x)*cos(y)) + will be close to atan2(0, 0), and highly unstable. + The ``cy`` fix for numerical instability below is from: *Graphics + Gems IV*, Paul Heckbert (editor), Academic Press, 1994, ISBN: + 0123361559. Specifically it comes from EulerAngles.c by Ken + Shoemake, and deals with the case where cos(y) is close to zero: + See: http://www.graphicsgems.org/ + The code appears to be licensed (from the website) as "can be used + without restrictions". + ''' + M = np.asarray(M) + if cy_thresh is None: + try: + cy_thresh = np.finfo(M.dtype).eps * 4 + except ValueError: + cy_thresh = _FLOAT_EPS_4 + r11, r12, r13, r21, r22, r23, r31, r32, r33 = M.flat + # cy: sqrt((cos(y)*cos(z))**2 + (cos(x)*cos(y))**2) + cy = math.sqrt(r33*r33 + r23*r23) + if seq=='zyx': + if cy > cy_thresh: # cos(y) not close to zero, standard form + z = math.atan2(-r12, r11) # atan2(cos(y)*sin(z), cos(y)*cos(z)) + y = math.atan2(r13, cy) # atan2(sin(y), cy) + x = math.atan2(-r23, r33) # atan2(cos(y)*sin(x), cos(x)*cos(y)) + else: # cos(y) (close to) zero, so x -> 0.0 (see above) + # so r21 -> sin(z), r22 -> cos(z) and + z = math.atan2(r21, r22) + y = math.atan2(r13, cy) # atan2(sin(y), cy) + x = 0.0 + elif seq=='xyz': + if cy > cy_thresh: + y = math.atan2(-r31, cy) + x = math.atan2(r32, r33) + z = math.atan2(r21, r11) + else: + z = 0.0 + if r31 < 0: + y = np.pi/2 + x = atan2(r12, r13) + else: + y = -np.pi/2 + else: + raise Exception('Sequence not recognized') + return z, y, x + +import functools +def euler2mat(z=0, y=0, x=0, isRadian=True): + ''' Return matrix for rotations around z, y and x axes + Uses the z, then y, then x convention above + Parameters + ---------- + z : scalar + Rotation angle in radians around z-axis (performed first) + y : scalar + Rotation angle in radians around y-axis + x : scalar + Rotation angle in radians around x-axis (performed last) + Returns + ------- + M : array shape (3,3) + Rotation matrix giving same rotation as for given angles + Examples + -------- + >>> zrot = 1.3 # radians + >>> yrot = -0.1 + >>> xrot = 0.2 + >>> M = euler2mat(zrot, yrot, xrot) + >>> M.shape == (3, 3) + True + The output rotation matrix is equal to the composition of the + individual rotations + >>> M1 = euler2mat(zrot) + >>> M2 = euler2mat(0, yrot) + >>> M3 = euler2mat(0, 0, xrot) + >>> composed_M = np.dot(M3, np.dot(M2, M1)) + >>> np.allclose(M, composed_M) + True + You can specify rotations by named arguments + >>> np.all(M3 == euler2mat(x=xrot)) + True + When applying M to a vector, the vector should column vector to the + right of M. If the right hand side is a 2D array rather than a + vector, then each column of the 2D array represents a vector. + >>> vec = np.array([1, 0, 0]).reshape((3,1)) + >>> v2 = np.dot(M, vec) + >>> vecs = np.array([[1, 0, 0],[0, 1, 0]]).T # giving 3x2 array + >>> vecs2 = np.dot(M, vecs) + Rotations are counter-clockwise. + >>> zred = np.dot(euler2mat(z=np.pi/2), np.eye(3)) + >>> np.allclose(zred, [[0, -1, 0],[1, 0, 0], [0, 0, 1]]) + True + >>> yred = np.dot(euler2mat(y=np.pi/2), np.eye(3)) + >>> np.allclose(yred, [[0, 0, 1],[0, 1, 0], [-1, 0, 0]]) + True + >>> xred = np.dot(euler2mat(x=np.pi/2), np.eye(3)) + >>> np.allclose(xred, [[1, 0, 0],[0, 0, -1], [0, 1, 0]]) + True + Notes + ----- + The direction of rotation is given by the right-hand rule (orient + the thumb of the right hand along the axis around which the rotation + occurs, with the end of the thumb at the positive end of the axis; + curl your fingers; the direction your fingers curl is the direction + of rotation). Therefore, the rotations are counterclockwise if + looking along the axis of rotation from positive to negative. + ''' + + if not isRadian: + z = ((np.pi)/180.) * z + y = ((np.pi)/180.) * y + x = ((np.pi)/180.) * x + assert z>=(-np.pi) and z < np.pi, 'Inapprorpriate z: %f' % z + assert y>=(-np.pi) and y < np.pi, 'Inapprorpriate y: %f' % y + assert x>=(-np.pi) and x < np.pi, 'Inapprorpriate x: %f' % x + + Ms = [] + if z: + cosz = math.cos(z) + sinz = math.sin(z) + Ms.append(np.array( + [[cosz, -sinz, 0], + [sinz, cosz, 0], + [0, 0, 1]])) + if y: + cosy = math.cos(y) + siny = math.sin(y) + Ms.append(np.array( + [[cosy, 0, siny], + [0, 1, 0], + [-siny, 0, cosy]])) + if x: + cosx = math.cos(x) + sinx = math.sin(x) + Ms.append(np.array( + [[1, 0, 0], + [0, cosx, -sinx], + [0, sinx, cosx]])) + if Ms: + return functools.reduce(np.dot, Ms[::-1]) + return np.eye(3) + +def euler2quat(z=0, y=0, x=0, isRadian=True): + ''' Return quaternion corresponding to these Euler angles + Uses the z, then y, then x convention above + Parameters + ---------- + z : scalar + Rotation angle in radians around z-axis (performed first) + y : scalar + Rotation angle in radians around y-axis + x : scalar + Rotation angle in radians around x-axis (performed last) + Returns + ------- + quat : array shape (4,) + Quaternion in w, x, y z (real, then vector) format + Notes + ----- + We can derive this formula in Sympy using: + 1. Formula giving quaternion corresponding to rotation of theta radians + about arbitrary axis: + http://mathworld.wolfram.com/EulerParameters.html + 2. Generated formulae from 1.) for quaternions corresponding to + theta radians rotations about ``x, y, z`` axes + 3. Apply quaternion multiplication formula - + http://en.wikipedia.org/wiki/Quaternions#Hamilton_product - to + formulae from 2.) to give formula for combined rotations. + ''' + + if not isRadian: + z = ((np.pi)/180.) * z + y = ((np.pi)/180.) * y + x = ((np.pi)/180.) * x + z = z/2.0 + y = y/2.0 + x = x/2.0 + cz = math.cos(z) + sz = math.sin(z) + cy = math.cos(y) + sy = math.sin(y) + cx = math.cos(x) + sx = math.sin(x) + return np.array([ + cx*cy*cz - sx*sy*sz, + cx*sy*sz + cy*cz*sx, + cx*cz*sy - sx*cy*sz, + cx*cy*sz + sx*cz*sy]) + +def pose_vec_to_mat(vec): + tx = vec[0] + ty = vec[1] + tz = vec[2] + trans = np.array([tx, ty, tz]).reshape((3,1)) + rot = euler2mat(vec[5], vec[4], vec[3]) + Tmat = np.concatenate((rot, trans), axis=1) + hfiller = np.array([0, 0, 0, 1]).reshape((1,4)) + Tmat = np.concatenate((Tmat, hfiller), axis=0) + return Tmat + +def dump_pose_seq_TUM(out_file, poses, times): + # First frame as the origin + first_pose = pose_vec_to_mat(poses[0]) + with open(out_file, 'w') as f: + for p in range(len(times)): + this_pose = pose_vec_to_mat(poses[p]) + this_pose = np.dot(first_pose, np.linalg.inv(this_pose)) + tx = this_pose[0, 3] + ty = this_pose[1, 3] + tz = this_pose[2, 3] + rot = this_pose[:3, :3] + qw, qx, qy, qz = rot2quat(rot) + f.write('%f %f %f %f %f %f %f %f\n' % (times[p], tx, ty, tz, qx, qy, qz, qw)) \ No newline at end of file diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/misc/cityscapes_sample_results.gif b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/misc/cityscapes_sample_results.gif new file mode 100644 index 0000000000000000000000000000000000000000..67df8c1a1ca174314721a11697248c774f1e7f82 Binary files /dev/null and b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/misc/cityscapes_sample_results.gif differ diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/misc/sample.png b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/misc/sample.png new file mode 100644 index 0000000000000000000000000000000000000000..3c88792beec6621761f321b3fc608e489809d7bd Binary files /dev/null and b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/misc/sample.png differ diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/modelarts_entry_acc.py b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/modelarts_entry_acc.py new file mode 100644 index 0000000000000000000000000000000000000000..ba34135513c086af52713808642f341dbe2faf27 --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/modelarts_entry_acc.py @@ -0,0 +1,38 @@ +import os +import argparse +import sys + +# 解析输入参数data_url +parser = argparse.ArgumentParser() +parser.add_argument("--data_url", type=str, default="/home/ma-user/modelarts/inputs/data_url_0") +parser.add_argument("--train_url", type=str, default="/home/ma-user/modelarts/outputs/train_url_0/") +# parser.add_argument("--work_url", type=str, default="/home/ma-user/modelarts/workspace/device0/") #added # deleted +config = parser.parse_args() + +print("[CANN-ZhongZhi] code_dir path is [%s]" % (sys.path[0])) +code_dir = sys.path[0] +os.chdir(code_dir) +work_dir = "/home/ma-user/modelarts/workspace/device0" # added +print("[CANN-ZhongZhi] work_dir path is [%s]" % (work_dir)) # "os.getcwd()" is changed to "work_dir" +# work_dir = os.getcwd() # added # deleted +print("[CANN-ZhongZhi] before train - list my run files:") +os.system("ls -al /usr/local/Ascend/ascend-toolkit/") + +print("[CANN-ZhongZhi] before train - list my dataset files:") +os.system("ls -al %s" % config.data_url) + +print("[CANN-ZhongZhi] start run train shell") +# 设置sh文件格式为linux可执行 +os.system("dos2unix ./test/*") + +# 执行train_full_1p.sh或者train_performance_1p.sh，需要用户自己指定 +# full和performance的差异，performance只需要执行很少的step，控制在15分钟以内，主要关注性能FPS +os.system("bash ./test/train_full_1p.sh --data_path=%s --output_path=%s " % (config.data_url, config.train_url)) + +print("[CANN-ZhongZhi] finish run train shell") + +# 将当前执行目录所有文件拷贝到obs的output进行备份 +print("[CANN-ZhongZhi] after train - list my output files:") +os.system("cp -r %s %s " % (work_dir, config.train_url)) # added +os.system("cp -r %s %s " % (code_dir, config.train_url)) +os.system("ls -al %s" % config.train_url) diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/modelarts_entry_perf.py b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/modelarts_entry_perf.py new file mode 100644 index 0000000000000000000000000000000000000000..3134c65bddb3825b04603acfcc24679fa4be7939 --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/modelarts_entry_perf.py @@ -0,0 +1,35 @@ +import os +import argparse +import sys + +# 解析输入参数data_url +parser = argparse.ArgumentParser() +parser.add_argument("--data_url", type=str, default="/home/ma-user/modelarts/inputs/data_url_0") +parser.add_argument("--train_url", type=str, default="/home/ma-user/modelarts/outputs/train_url_0/") +config = parser.parse_args() + +print("[CANN-ZhongZhi] code_dir path is [%s]" % (sys.path[0])) +code_dir = sys.path[0] +os.chdir(code_dir) +print("[CANN-ZhongZhi] work_dir path is [%s]" % (os.getcwd())) + +print("[CANN-ZhongZhi] before train - list my run files:") +os.system("ls -al /usr/local/Ascend/ascend-toolkit/") + +print("[CANN-ZhongZhi] before train - list my dataset files:") +os.system("ls -al %s" % config.data_url) + +print("[CANN-ZhongZhi] start run train shell") +# 设置sh文件格式为linux可执行 +os.system("dos2unix ./test/*") + +# 执行train_full_1p.sh或者train_performance_1p.sh，需要用户自己指定 +# full和performance的差异，performance只需要执行很少的step，控制在15分钟以内，主要关注性能FPS +os.system("bash ./test/train_performance_1p.sh --data_path=%s --output_path=%s " % (config.data_url, config.train_url)) + +print("[CANN-ZhongZhi] finish run train shell") + +# 将当前执行目录所有文件拷贝到obs的output进行备份 +print("[CANN-ZhongZhi] after train - list my output files:") +os.system("cp -r %s %s " % (code_dir, config.train_url)) +os.system("ls -al %s" % config.train_url) diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/modelzoo_level.txt b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/modelzoo_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..14893858767b16393ac4273d63121c77175b0199 --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/modelzoo_level.txt @@ -0,0 +1,3 @@ +FuncStatus:OK +PerfStatus:OK +PrecisionStatus:NOK \ No newline at end of file diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/nets.py b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/nets.py new file mode 100644 index 0000000000000000000000000000000000000000..ff5f6e3342467ba169e2ace1509617ae35fe7c58 --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/nets.py @@ -0,0 +1,175 @@ +# +# Copyright 2017 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from __future__ import division +from npu_bridge.npu_init import * +import tensorflow as tf +import tensorflow.contrib.slim as slim +from tensorflow.contrib.layers.python.layers import utils +import numpy as np + +# Range of disparity/inverse depth values +DISP_SCALING = 10 +MIN_DISP = 0.01 + +def resize_like(inputs, ref): + iH, iW = inputs.get_shape()[1], inputs.get_shape()[2] + rH, rW = ref.get_shape()[1], ref.get_shape()[2] + if iH == rH and iW == rW: + return inputs + return tf.image.resize_nearest_neighbor(inputs, [rH.value, rW.value]) + +def pose_exp_net(tgt_image, src_image_stack, do_exp=True, is_training=True): + inputs = tf.concat([tgt_image, src_image_stack], axis=3) + H = inputs.get_shape()[1].value + W = inputs.get_shape()[2].value + num_source = int(src_image_stack.get_shape()[3].value//3) + with tf.variable_scope('pose_exp_net') as sc: + end_points_collection = sc.original_name_scope + '_end_points' + with slim.arg_scope([slim.conv2d, slim.conv2d_transpose], + normalizer_fn=None, + weights_regularizer=slim.l2_regularizer(0.05), + activation_fn=tf.nn.relu, + outputs_collections=end_points_collection): + # cnv1 to cnv5b are shared between pose and explainability prediction + cnv1 = slim.conv2d(inputs,16, [7, 7], stride=2, scope='cnv1') + cnv2 = slim.conv2d(cnv1, 32, [5, 5], stride=2, scope='cnv2') + cnv3 = slim.conv2d(cnv2, 64, [3, 3], stride=2, scope='cnv3') + cnv4 = slim.conv2d(cnv3, 128, [3, 3], stride=2, scope='cnv4') + cnv5 = slim.conv2d(cnv4, 256, [3, 3], stride=2, scope='cnv5') + # Pose specific layers + with tf.variable_scope('pose'): + cnv6 = slim.conv2d(cnv5, 256, [3, 3], stride=2, scope='cnv6') + cnv7 = slim.conv2d(cnv6, 256, [3, 3], stride=2, scope='cnv7') + pose_pred = slim.conv2d(cnv7, 6*num_source, [1, 1], scope='pred', + stride=1, normalizer_fn=None, activation_fn=None) + pose_avg = tf.reduce_mean(pose_pred, [1, 2]) + # Empirically we found that scaling by a small constant + # facilitates training. + pose_final = 0.01 * tf.reshape(pose_avg, [-1, num_source, 6]) + # Exp mask specific layers + if do_exp: + with tf.variable_scope('exp'): + upcnv5 = slim.conv2d_transpose(cnv5, 256, [3, 3], stride=2, scope='upcnv5') + + upcnv4 = slim.conv2d_transpose(upcnv5, 128, [3, 3], stride=2, scope='upcnv4') + mask4 = slim.conv2d(upcnv4, num_source * 2, [3, 3], stride=1, scope='mask4', + normalizer_fn=None, activation_fn=None) + + upcnv3 = slim.conv2d_transpose(upcnv4, 64, [3, 3], stride=2, scope='upcnv3') + mask3 = slim.conv2d(upcnv3, num_source * 2, [3, 3], stride=1, scope='mask3', + normalizer_fn=None, activation_fn=None) + + upcnv2 = slim.conv2d_transpose(upcnv3, 32, [5, 5], stride=2, scope='upcnv2') + mask2 = slim.conv2d(upcnv2, num_source * 2, [5, 5], stride=1, scope='mask2', + normalizer_fn=None, activation_fn=None) + + upcnv1 = slim.conv2d_transpose(upcnv2, 16, [7, 7], stride=2, scope='upcnv1') + mask1 = slim.conv2d(upcnv1, num_source * 2, [7, 7], stride=1, scope='mask1', + normalizer_fn=None, activation_fn=None) + else: + mask1 = None + mask2 = None + mask3 = None + mask4 = None + end_points = utils.convert_collection_to_dict(end_points_collection) + return pose_final, [mask1, mask2, mask3, mask4], end_points + +def disp_net(tgt_image, is_training=True): + H = tgt_image.get_shape()[1].value + W = tgt_image.get_shape()[2].value + with tf.variable_scope('depth_net') as sc: + end_points_collection = sc.original_name_scope + '_end_points' + with slim.arg_scope([slim.conv2d, slim.conv2d_transpose], + normalizer_fn=None, + weights_regularizer=slim.l2_regularizer(0.05), + activation_fn=tf.nn.relu, + outputs_collections=end_points_collection): + cnv1 = slim.conv2d(tgt_image, 32, [7, 7], stride=2, scope='cnv1') + cnv1b = slim.conv2d(cnv1, 32, [7, 7], stride=1, scope='cnv1b') + cnv2 = slim.conv2d(cnv1b, 64, [5, 5], stride=2, scope='cnv2') + cnv2b = slim.conv2d(cnv2, 64, [5, 5], stride=1, scope='cnv2b') + cnv3 = slim.conv2d(cnv2b, 128, [3, 3], stride=2, scope='cnv3') + cnv3b = slim.conv2d(cnv3, 128, [3, 3], stride=1, scope='cnv3b') + cnv4 = slim.conv2d(cnv3b, 256, [3, 3], stride=2, scope='cnv4') + cnv4b = slim.conv2d(cnv4, 256, [3, 3], stride=1, scope='cnv4b') + cnv5 = slim.conv2d(cnv4b, 512, [3, 3], stride=2, scope='cnv5') + cnv5b = slim.conv2d(cnv5, 512, [3, 3], stride=1, scope='cnv5b') + cnv6 = slim.conv2d(cnv5b, 512, [3, 3], stride=2, scope='cnv6') + cnv6b = slim.conv2d(cnv6, 512, [3, 3], stride=1, scope='cnv6b') + cnv7 = slim.conv2d(cnv6b, 512, [3, 3], stride=2, scope='cnv7') + cnv7b = slim.conv2d(cnv7, 512, [3, 3], stride=1, scope='cnv7b') + + upcnv7 = slim.conv2d_transpose(cnv7b, 512, [3, 3], stride=2, scope='upcnv7') + # There might be dimension mismatch due to uneven down/up-sampling + upcnv7 = resize_like(upcnv7, cnv6b) + i7_in = tf.concat([upcnv7, cnv6b], axis=3) + icnv7 = slim.conv2d(i7_in, 512, [3, 3], stride=1, scope='icnv7') + + upcnv6 = slim.conv2d_transpose(icnv7, 512, [3, 3], stride=2, scope='upcnv6') + upcnv6 = resize_like(upcnv6, cnv5b) + i6_in = tf.concat([upcnv6, cnv5b], axis=3) + icnv6 = slim.conv2d(i6_in, 512, [3, 3], stride=1, scope='icnv6') + + upcnv5 = slim.conv2d_transpose(icnv6, 256, [3, 3], stride=2, scope='upcnv5') + upcnv5 = resize_like(upcnv5, cnv4b) + i5_in = tf.concat([upcnv5, cnv4b], axis=3) + icnv5 = slim.conv2d(i5_in, 256, [3, 3], stride=1, scope='icnv5') + + upcnv4 = slim.conv2d_transpose(icnv5, 128, [3, 3], stride=2, scope='upcnv4') + i4_in = tf.concat([upcnv4, cnv3b], axis=3) + icnv4 = slim.conv2d(i4_in, 128, [3, 3], stride=1, scope='icnv4') + disp4 = DISP_SCALING * slim.conv2d(icnv4, 1, [3, 3], stride=1, + activation_fn=tf.sigmoid, normalizer_fn=None, scope='disp4') + MIN_DISP + disp4_up = tf.image.resize_bilinear(disp4, [np.int(H/4), np.int(W/4)]) + + upcnv3 = slim.conv2d_transpose(icnv4, 64, [3, 3], stride=2, scope='upcnv3') + i3_in = tf.concat([upcnv3, cnv2b, disp4_up], axis=3) + icnv3 = slim.conv2d(i3_in, 64, [3, 3], stride=1, scope='icnv3') + disp3 = DISP_SCALING * slim.conv2d(icnv3, 1, [3, 3], stride=1, + activation_fn=tf.sigmoid, normalizer_fn=None, scope='disp3') + MIN_DISP + disp3_up = tf.image.resize_bilinear(disp3, [np.int(H/2), np.int(W/2)]) + + upcnv2 = slim.conv2d_transpose(icnv3, 32, [3, 3], stride=2, scope='upcnv2') + i2_in = tf.concat([upcnv2, cnv1b, disp3_up], axis=3) + icnv2 = slim.conv2d(i2_in, 32, [3, 3], stride=1, scope='icnv2') + disp2 = DISP_SCALING * slim.conv2d(icnv2, 1, [3, 3], stride=1, + activation_fn=tf.sigmoid, normalizer_fn=None, scope='disp2') + MIN_DISP + disp2_up = tf.image.resize_bilinear(disp2, [H, W]) + + upcnv1 = slim.conv2d_transpose(icnv2, 16, [3, 3], stride=2, scope='upcnv1') + i1_in = tf.concat([upcnv1, disp2_up], axis=3) + icnv1 = slim.conv2d(i1_in, 16, [3, 3], stride=1, scope='icnv1') + disp1 = DISP_SCALING * slim.conv2d(icnv1, 1, [3, 3], stride=1, + activation_fn=tf.sigmoid, normalizer_fn=None, scope='disp1') + MIN_DISP + + end_points = utils.convert_collection_to_dict(end_points_collection) + return [disp1, disp2, disp3, disp4], end_points + + diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/requirements.txt b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..8fbe34ecb57c48fb0978e587ab05901b25800af9 --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/requirements.txt @@ -0,0 +1,6 @@ +python==3.7.5 +tensorflow==1.15.0 +matplotlib==2.1.2 +numpy==1.16.2 +scipy==1.0.1 + diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/test/train_full_1p.sh b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/test/train_full_1p.sh new file mode 100644 index 0000000000000000000000000000000000000000..6ecc1678ec6cccaac9141e579bc74e14925f88a9 --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/test/train_full_1p.sh @@ -0,0 +1,174 @@ +#!/bin/bash + +########################################################## +#########第3行 至 100行，请一定不要、不要、不要修改########## +#########第3行 至 100行，请一定不要、不要、不要修改########## +#########第3行 至 100行，请一定不要、不要、不要修改########## +########################################################## +# shell脚本所在路径 +cur_path=`echo $(cd $(dirname $0);pwd)` + +# 判断当前shell是否是performance +perf_flag=`echo $0 | grep performance | wc -l` + +# 当前执行网络的名称 +Network=`echo $(cd $(dirname $0);pwd) | awk -F"/" '{print $(NF-1)}'` + +export RANK_SIZE=1 +export RANK_ID=0 +export JOB_ID=10087 + +# 路径参数初始化 +data_path="" +output_path="" + +# 帮助信息，不需要修改 +if [[ $1 == --help || $1 == -h ]];then + echo"usage:./train_performance_1P.sh " + echo " " + echo "parameter explain: + --data_path # dataset of training + --output_path # output of training + --train_steps # max_step for training + --train_epochs # max_epoch for training + --batch_size # batch size + -h/--help show help message + " + exit 1 +fi + +# 参数校验，不需要修改 +for para in $* +do + if [[ $para == --data_path* ]];then + data_path=`echo ${para#*=}` + elif [[ $para == --output_path* ]];then + output_path=`echo ${para#*=}` + elif [[ $para == --train_steps* ]];then + train_steps=`echo ${para#*=}` + elif [[ $para == --train_epochs* ]];then + train_epochs=`echo ${para#*=}` + elif [[ $para == --batch_size* ]];then + batch_size=`echo ${para#*=}` + fi +done + +# 校验是否传入data_path,不需要修改 +if [[ $data_path == "" ]];then + echo "[Error] para \"data_path\" must be config" + exit 1 +fi + +# 校验是否传入output_path,不需要修改 +if [[ $output_path == "" ]];then + output_path="./test/output/${ASCEND_DEVICE_ID}" +fi + +# 设置打屏日志文件名，请保留，文件名为${print_log} +print_log="./test/output/${ASCEND_DEVICE_ID}/train_${ASCEND_DEVICE_ID}.log" +etp_flag=${etp_running_flag} +if [ x"${etp_flag}" != xtrue ]; +then + echo "running without etp..." + print_log_name=`ls /home/ma-user/modelarts/log/ | grep proc-rank` + print_log="/home/ma-user/modelarts/log/${print_log_name}" +fi +echo ${print_log} + +CaseName="" +function get_casename() +{ + if [ x"${perf_flag}" = x1 ]; + then + CaseName=${Network}_bs${batch_size}_${RANK_SIZE}'p'_'perf' + else + CaseName=${Network}_bs${batch_size}_${RANK_SIZE}'p'_'acc' + fi +} + +# 跳转到code目录 +cd ${cur_path}/../ +rm -rf ./test/output/${ASCEND_DEVICE_ID} +mkdir -p ./test/output/${ASCEND_DEVICE_ID} + +# 训练开始时间记录，不需要修改 +start_time=$(date +%s) +########################################################## +#########第3行 至 100行，请一定不要、不要、不要修改########## +#########第3行 至 100行，请一定不要、不要、不要修改########## +#########第3行 至 100行，请一定不要、不要、不要修改########## +########################################################## + +#========================================================= +#========================================================= +#========训练执行命令，需要根据您的网络进行修改============== +#========================================================= +#========================================================= +#基础参数，需要模型审视修改 +batch_size=64 + +if [ x"${etp_flag}" != xtrue ]; +then + #python3.7 ./LeNet.py --data_path=${data_path} --output_path=${output_path} + python3.7 ./train.py --dataset_dir=${data_path}'data' --checkpoint_dir=${output_path}'outputtt/' --img_width=416 --image_height=128 --batch_size=4 + python3.7 ./test_kitti_pose.py --test_seq=10 --dataset_dir=${data_path} --output_dir=${output_path}'kitti_eval/pose_data/ours_results/' --ckpt_file=${output_path}'outputtt/model-199545' + # python3.7 ./kitti_eval/eval_pose.py --gtruth_dir=${output_path}'kitti_eval/pose_data/ground_truth/10/' --pred_dir=${output_path}'kitti_eval/pose_data/ours_results/' +else + #python3.7 ./LeNet.py --data_path=${data_path} --output_path=${output_path} > ${print_log} + python3.7 ./train.py --dataset_dir=${data_path}'data' --checkpoint_dir=${output_path}'outputtt/' --img_width=416 --image_height=128 --batch_size=4 > ${print_log} + python3.7 ./test_kitti_pose.py --test_seq=10 --dataset_dir=${data_path} --output_dir=${output_path}'kitti_eval/pose_data/ours_results/' --ckpt_file=${output_path}'outputtt/model-199545' + # python3.7 ./kitti_eval/eval_pose.py --gtruth_dir=${output_path}'kitti_eval/pose_data/ground_truth/10/' --pred_dir=${output_path}'kitti_eval/pose_data/ours_results/' > ${eval_log} +fi + +# 性能相关数据计算 +# StepTime=`grep "sec/step :" ${print_log} | tail -n 10 | awk '{print $NF}' | awk '{sum+=$1} END {print sum/NR}'` +# FPS=`awk 'BEGIN{printf "%.2f\n", '${batch_size}'/'${StepTime}'}'` + +# 精度相关数据计算 +# train_accuracy=`grep "Final Accuracy accuracy" ${print_log} | awk '{print $NF}'` +train_accuracy=`grep "ATE mean" ${eval_log} | awk '{print $3,$5}'` +# 提取所有loss打印信息 +grep "loss :" ${print_log} | awk -F ":" '{print $4}' | awk -F "-" '{print $1}' > ./test/output/${ASCEND_DEVICE_ID}/my_output_loss.txt + + +########################################################### +#########后面的所有内容请不要修改########################### +#########后面的所有内容请不要修改########################### +#########后面的所有内容请不要修改########################### +########################################################### + +# 获取最终的casename，请保留，case文件名为${CaseName} +get_casename + +# 重命名loss文件 +if [ -f ./test/output/${ASCEND_DEVICE_ID}/my_output_loss.txt ]; +then + mv ./test/output/${ASCEND_DEVICE_ID}/my_output_loss.txt ./test/output/${ASCEND_DEVICE_ID}/${CaseName}_loss.txt +fi + +# 训练端到端耗时 +end_time=$(date +%s) +e2e_time=$(( $end_time - $start_time )) + +echo "------------------ Final result ------------------" +# 输出性能FPS/单step耗时/端到端耗时 +echo "Final Performance images/sec : $FPS" +echo "Final Performance sec/step : $StepTime" +echo "E2E Training Duration sec : $e2e_time" + +# 输出训练精度 +echo "Final Train Accuracy : ${train_accuracy}" + +# 最后一个迭代loss值，不需要修改 +ActualLoss=(`awk 'END {print $NF}' $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}_loss.txt`) + +#关键信息打印到${CaseName}.log中，不需要修改 +echo "Network = ${Network}" > $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log +echo "RankSize = ${RANK_SIZE}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log +echo "BatchSize = ${batch_size}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log +echo "DeviceType = `uname -m`" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log +echo "CaseName = ${CaseName}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log +echo "ActualFPS = ${FPS}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log +echo "TrainingTime = ${StepTime}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log +echo "ActualLoss = ${ActualLoss}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log +echo "E2ETrainingTime = ${e2e_time}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log \ No newline at end of file diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/test/train_performance_1p.sh b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/test/train_performance_1p.sh new file mode 100644 index 0000000000000000000000000000000000000000..fc9b3a22114d47b4c6a7c71aebb842f2142c5e5a --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/test/train_performance_1p.sh @@ -0,0 +1,177 @@ +#!/bin/bash + +########################################################## +#########第3行 至 100行，请一定不要、不要、不要修改########## +#########第3行 至 100行，请一定不要、不要、不要修改########## +#########第3行 至 100行，请一定不要、不要、不要修改########## +########################################################## +# shell脚本所在路径 +cur_path=`echo $(cd $(dirname $0);pwd)` + +# 判断当前shell是否是performance +perf_flag=`echo $0 | grep performance | wc -l` + +# 当前执行网络的名称 +Network=`echo $(cd $(dirname $0);pwd) | awk -F"/" '{print $(NF-1)}'` + +export RANK_SIZE=1 +export RANK_ID=0 +export JOB_ID=10087 + +# 路径参数初始化 +data_path="" +output_path="" + +# 帮助信息，不需要修改 +if [[ $1 == --help || $1 == -h ]];then + echo"usage:./train_performance_1P.sh " + echo " " + echo "parameter explain: + --data_path # dataset of training + --output_path # output of training + --train_steps # max_step for training + --train_epochs # max_epoch for training + --batch_size # batch size + -h/--help show help message + " + exit 1 +fi + +# 参数校验，不需要修改 +for para in $* +do + if [[ $para == --data_path* ]];then + data_path=`echo ${para#*=}` + elif [[ $para == --output_path* ]];then + output_path=`echo ${para#*=}` + elif [[ $para == --train_steps* ]];then + train_steps=`echo ${para#*=}` + elif [[ $para == --train_epochs* ]];then + train_epochs=`echo ${para#*=}` + elif [[ $para == --batch_size* ]];then + batch_size=`echo ${para#*=}` + fi +done + +# 校验是否传入data_path,不需要修改 +if [[ $data_path == "" ]];then + echo "[Error] para \"data_path\" must be config" + exit 1 +fi + +# 校验是否传入output_path,不需要修改 +if [[ $output_path == "" ]];then + output_path="./test/output/${ASCEND_DEVICE_ID}" +fi + +# 设置打屏日志文件名，请保留，文件名为${print_log} +print_log="./test/output/${ASCEND_DEVICE_ID}/train_${ASCEND_DEVICE_ID}.log" +etp_flag=${etp_running_flag} +if [ x"${etp_flag}" != xtrue ]; +then + echo "running without etp..." + print_log_name=`ls /home/ma-user/modelarts/log/ | grep proc-rank` + print_log="/home/ma-user/modelarts/log/${print_log_name}" +fi +echo ${print_log} + +CaseName="" +function get_casename() +{ + if [ x"${perf_flag}" = x1 ]; + then + CaseName=${Network}_bs${batch_size}_${RANK_SIZE}'p'_'perf' + else + CaseName=${Network}_bs${batch_size}_${RANK_SIZE}'p'_'acc' + fi +} + +# 跳转到code目录 +cd ${cur_path}/../ +rm -rf ./test/output/${ASCEND_DEVICE_ID} +mkdir -p ./test/output/${ASCEND_DEVICE_ID} + +# 训练开始时间记录，不需要修改 +start_time=$(date +%s) +########################################################## +#########第3行 至 100行，请一定不要、不要、不要修改########## +#########第3行 至 100行，请一定不要、不要、不要修改########## +#########第3行 至 100行，请一定不要、不要、不要修改########## +########################################################## + +#========================================================= +#========================================================= +#========训练执行命令，需要根据您的网络进行修改============== +#========================================================= +#========================================================= +#基础参数，需要模型审视修改 +train_epochs=2 +train_steps=100 +batch_size=64 + + +if [ x"${etp_flag}" != xtrue ]; +then + # python3.7 ./LeNet.py --data_path=${data_path} --output_path=${output_path} --steps=${train_steps} # changed + # python train.py --dataset_dir=/path/to/the/formatted/data/ --checkpoint_dir=/where/to/store/checkpoints/ --img_width=416 --img_height=128 --batch_size=4 + #python3.7 ./train.py --data_path=${data_path}'data/' --checkpoint_dir=${output_path}'outputtt/' --output_path=${output_path} --img_width=416 --img_height=128 --batch_size=4 # added + python3.7 ./train.py --dataset_dir=${data_path}'data/' --checkpoint_dir=${output_path}'outputtt/' --data_path=${data_path} --output_path=${output_path} --img_width=416 --image_height=128 --batch_size=4 #改 +else + # python3.7 ./LeNet.py --data_path=${data_path} --output_path=${output_path} --steps=${train_steps} > ${print_log} # changed + #python3.7 ./train.py --data_path=${data_path}'data/' --checkpoint_dir=${output_path}'outputtt/' --output_path=${output_path} --img_width=416 --img_height=128 --batch_size=4 > ${print_log} # added + python3.7 ./train.py --dataset_dir=${data_path}'data/' --checkpoint_dir=${output_path}'outputtt/' --data_path=${data_path} --output_path=${output_path} --img_width=416 --image_height=128 --batch_size=4 > ${print_log} #改 +fi + +# 性能相关数据计算 +# StepTime=`grep "sec/step :" ${print_log} | tail -n 10 | awk '{print $NF}' | awk '{sum+=$1} END {print sum/NR}'` # deleted +StepTime=`grep "sec/step :" ${print_log} | tail -n 10 | awk '{print $}' | awk '{sum+=$1} END {print sum/NR}'` # added +FPS=`awk 'BEGIN{printf "%.2f\n", '${batch_size}'/'${StepTime}'}'` + +# 精度相关数据计算 +# train_accuracy=`grep "Final Accuracy accuracy" ${print_log} | awk '{print $NF}'` # deleted +train_accuracy=`grep "ATE mean" ${print_log} | awk '{print $3,$5}'` # added +# 提取所有loss打印信息 +grep "loss :" ${print_log} | awk -F ":" '{print $4}' | awk -F "-" '{print $1}' > ./test/output/${ASCEND_DEVICE_ID}/my_output_loss.txt + + +########################################################### +#########后面的所有内容请不要修改########################### +#########后面的所有内容请不要修改########################### +#########后面的所有内容请不要修改########################### +########################################################### + +# 获取最终的casename，请保留，case文件名为${CaseName} +get_casename + +# 重命名loss文件 +if [ -f ./test/output/${ASCEND_DEVICE_ID}/my_output_loss.txt ]; +then + mv ./test/output/${ASCEND_DEVICE_ID}/my_output_loss.txt ./test/output/${ASCEND_DEVICE_ID}/${CaseName}_loss.txt +fi + +# 训练端到端耗时 +end_time=$(date +%s) +e2e_time=$(( $end_time - $start_time )) + +echo "------------------ Final result ------------------" +# 输出性能FPS/单step耗时/端到端耗时 +echo "Final Performance images/sec : $FPS" +echo "Final Performance sec/step : $StepTime" +echo "E2E Training Duration sec : $e2e_time" + +# 输出训练精度 +echo "Final Train Accuracy : ${train_accuracy}" + +# 最后一个迭代loss值，不需要修改 +ActualLoss=(`awk 'END {print $NF}' $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}_loss.txt`) + +#关键信息打印到${CaseName}.log中，不需要修改 +echo "Network = ${Network}" > $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log +echo "RankSize = ${RANK_SIZE}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log +echo "BatchSize = ${batch_size}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log +echo "DeviceType = `uname -m`" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log +echo "CaseName = ${CaseName}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log +echo "ActualFPS = ${FPS}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log +echo "TrainingTime = ${StepTime}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log +echo "ActualLoss = ${ActualLoss}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log +echo "E2ETrainingTime = ${e2e_time}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log \ No newline at end of file diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/test_kitti_depth.py b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/test_kitti_depth.py new file mode 100644 index 0000000000000000000000000000000000000000..39df1c72e89f00761fad7eff2d69cb6b54d80686 --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/test_kitti_depth.py @@ -0,0 +1,109 @@ +# +# Copyright 2017 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from __future__ import division +from npu_bridge.npu_init import * +import tensorflow as tf +import numpy as np +import os +import cv2#li +import matplotlib.pyplot as plt#li +# import scipy.misc +import PIL.Image as pil +from SfMLearner import SfMLearner + +plt.switch_backend('agg')#li +flags = tf.app.flags +flags.DEFINE_integer("batch_size", 4, "The size of of a sample batch") +flags.DEFINE_integer("img_height", 128, "Image height") +flags.DEFINE_integer("img_width", 416, "Image width") +flags.DEFINE_string("dataset_dir", None, "Dataset directory") +flags.DEFINE_string("output_dir", None, "Output directory") +flags.DEFINE_string("ckpt_file", None, "checkpoint file") +FLAGS = flags.FLAGS + +def main(_): + with open('/home/ma-user/modelarts/user-job-dir/code/data/kitti/test_files_eigen.txt', 'r') as f: + test_files = f.readlines() + test_files = [FLAGS.dataset_dir + t[:-1] for t in test_files] + if not os.path.exists(FLAGS.output_dir): + os.makedirs(FLAGS.output_dir) + basename = os.path.basename(FLAGS.ckpt_file) + output_file = FLAGS.output_dir + '/' + basename + sfm = SfMLearner() + sfm.setup_inference(img_height=FLAGS.img_height, + img_width=FLAGS.img_width, + batch_size=FLAGS.batch_size, + mode='depth') + saver = tf.train.Saver([var for var in tf.model_variables()]) + config = tf.ConfigProto() + config.gpu_options.allow_growth = True + plt.ion()#li + with tf.Session(config=npu_config_proto(config_proto=config)) as sess: + saver.restore(sess, FLAGS.ckpt_file) + pred_all = [] + for t in range(0, len(test_files), FLAGS.batch_size): + if t % 100 == 0: + print('processing %s: %d/%d' % (basename, t, len(test_files))) + inputs = np.zeros( + (FLAGS.batch_size, FLAGS.img_height, FLAGS.img_width, 3), + dtype=np.uint8) + for b in range(FLAGS.batch_size): + idx = t + b + if idx >= len(test_files): + break + fh = open(test_files[idx], 'rb') + raw_im = pil.open(fh) + scaled_im = raw_im.resize((FLAGS.img_width, FLAGS.img_height), pil.ANTIALIAS) + inputs[b] = np.array(scaled_im) + # im = scipy.misc.imread(test_files[idx]) + # inputs[b] = scipy.misc.imresize(im, (FLAGS.img_height, FLAGS.img_width)) + pred = sfm.inference(inputs, sess, mode='depth') + lzr = 1 + for b in range(FLAGS.batch_size): + idx = t + b + if idx >= len(test_files): + break + pred_all.append(pred['depth'][b,:,:,0]) + + plt.subplot(211)#li + plt.imshow(scaled_im, cmap='gray')#li + plt.subplot(212)#li + plt.imshow(pred['depth'][b,:,:,0], cmap='gray')#li + + plt.pause(0.05)#li + lzr=lzr+1 + + plt.savefig('/users/lzr2019040707014/depth-output/%d.png'%(lzr+1)) + np.save(output_file, pred_all) + plt.close() + +if __name__ == '__main__': + tf.app.run() + diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/test_kitti_pose.py b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/test_kitti_pose.py new file mode 100644 index 0000000000000000000000000000000000000000..9fd61594517dcccdb0c547de82064926fec61fb6 --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/test_kitti_pose.py @@ -0,0 +1,128 @@ +# +# Copyright 2017 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from __future__ import division +from npu_bridge.npu_init import * +import os +import math +import scipy.misc +import tensorflow as tf +import numpy as np +from glob import glob +from SfMLearner import SfMLearner +from kitti_eval.pose_evaluation_utils import dump_pose_seq_TUM + +flags = tf.app.flags +flags.DEFINE_integer("batch_size", 1, "The size of of a sample batch") +flags.DEFINE_integer("img_height", 128, "Image height") +flags.DEFINE_integer("img_width", 416, "Image width") +flags.DEFINE_integer("seq_length", 5, "Sequence length for each example") +flags.DEFINE_integer("test_seq", 9, "Sequence id to test") +flags.DEFINE_string("dataset_dir", None, "Dataset directory") +flags.DEFINE_string("output_dir", None, "Output directory") +flags.DEFINE_string("ckpt_file", None, "checkpoint file") +FLAGS = flags.FLAGS + +def load_image_sequence(dataset_dir, + frames, + tgt_idx, + seq_length, + img_height, + img_width): + half_offset = int((seq_length - 1)/2) + for o in range(-half_offset, half_offset+1): + curr_idx = tgt_idx + o + curr_drive, curr_frame_id = frames[curr_idx].split(' ') + img_file = os.path.join( + dataset_dir, 'sequences', '%s/image_2/%s.png' % (curr_drive, curr_frame_id)) + curr_img = scipy.misc.imread(img_file) + curr_img = scipy.misc.imresize(curr_img, (img_height, img_width)) + if o == -half_offset: + image_seq = curr_img + else: + image_seq = np.hstack((image_seq, curr_img)) + return image_seq + +def is_valid_sample(frames, tgt_idx, seq_length): + N = len(frames) + tgt_drive, _ = frames[tgt_idx].split(' ') + max_src_offset = int((seq_length - 1)/2) + min_src_idx = tgt_idx - max_src_offset + max_src_idx = tgt_idx + max_src_offset + if min_src_idx < 0 or max_src_idx >= N: + return False + # TODO: unnecessary to check if the drives match + min_src_drive, _ = frames[min_src_idx].split(' ') + max_src_drive, _ = frames[max_src_idx].split(' ') + if tgt_drive == min_src_drive and tgt_drive == max_src_drive: + return True + return False + +def main(): + sfm = SfMLearner() + sfm.setup_inference(FLAGS.img_height, + FLAGS.img_width, + 'pose', + FLAGS.seq_length) + saver = tf.train.Saver([var for var in tf.trainable_variables()]) + + if not os.path.isdir(FLAGS.output_dir): + os.makedirs(FLAGS.output_dir) + seq_dir = os.path.join(FLAGS.dataset_dir, 'sequences', '%.2d' % FLAGS.test_seq) + img_dir = os.path.join(seq_dir, 'image_2') + N = len(glob(img_dir + '/*.jpg')) # "pn" was changed to "jp" + test_frames = ['%.2d %.6d' % (FLAGS.test_seq, n) for n in range(N)] + with open(FLAGS.dataset_dir + 'sequences/%.2d/times.txt' % FLAGS.test_seq, 'r') as f: + times = f.readlines() + times = np.array([float(s[:-1]) for s in times]) + max_src_offset = (FLAGS.seq_length - 1)//2 + # with tf.Session(config=npu_config_proto()) as sess: # deleted + with tf.Session() as sess: + saver.restore(sess, FLAGS.ckpt_file) + for tgt_idx in range(N): + if not is_valid_sample(test_frames, tgt_idx, FLAGS.seq_length): + continue + if tgt_idx % 100 == 0: + print('Progress: %d/%d' % (tgt_idx, N)) + # TODO: currently assuming batch_size = 1 + image_seq = load_image_sequence(FLAGS.dataset_dir, + test_frames, + tgt_idx, + FLAGS.seq_length, + FLAGS.img_height, + FLAGS.img_width) + pred = sfm.inference(image_seq[None, :, :, :], sess, mode='pose') + pred_poses = pred['pose'][0] + # Insert the target pose [0, 0, 0, 0, 0, 0] + pred_poses = np.insert(pred_poses, max_src_offset, np.zeros((1,6)), axis=0) + curr_times = times[tgt_idx - max_src_offset:tgt_idx + max_src_offset + 1] + out_file = FLAGS.output_dir + '%.6d.txt' % (tgt_idx - max_src_offset) + dump_pose_seq_TUM(out_file, pred_poses, curr_times) + +main() diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/train.py b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/train.py new file mode 100644 index 0000000000000000000000000000000000000000..e0d15a3491fd8d6eee6ac2fd193d81d0ee9cff74 --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/train.py @@ -0,0 +1,90 @@ +# +# Copyright 2017 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from __future__ import division +from npu_bridge.npu_init import * +import tensorflow as tf +import pprint +import random +import numpy as np +from SfMLearner import SfMLearner +import os +# from sqlalchemy.sql.operators import custom_op # added # deleted +import precision_tool.tf_config as npu_tf_config # added + +config_proto = tf.ConfigProto() # added +custom_op = config_proto.graph_options.rewrite_options.custom_optimizers.add() # added +custom_op.name = "NpuOptimizer" # added +config_proto.graph_options.rewrite_options.remapping = RewriterConfig.OFF # added +config_proto.graph_options.rewrite_options.memory_optimization = RewriterConfig.OFF # added +custom_op.parameter_map["dump_path"].s = tf.compat.as_bytes("/home/ma-user/modelarts/workspace/device0") # added +custom_op.parameter_map["enable_dump_debug"].b = True # added +custom_op.parameter_map["dump_debug_mode"].s = tf.compat.as_bytes("all") # added +# custom_op.parameter_map["precision_mode"].s = tf.compat.as_bytes("allow_mix_precision") # added # deleted +# custom_op.parameter_map["fusion_switch_file"].s = tf.compat.as_bytes("F:/7/Study/Project/CANN/220108/SfMLearner-master_for_TensorFlow/fusion_switch.cfg") # added # deleted + +flags = tf.app.flags +flags.DEFINE_string("dataset_dir", "", "Dataset directory") +flags.DEFINE_string("checkpoint_dir", "./checkpoints/", "Directory name to save the checkpoints") +flags.DEFINE_string("init_checkpoint_file", None, "Specific checkpoint file to initialize from") +flags.DEFINE_string("num_source", None, "add configuration") +flags.DEFINE_string("num_scales", None, "add configuration") +flags.DEFINE_float("learning_rate", 0.0002, "Learning rate of for adam") +flags.DEFINE_float("beta1", 0.9, "Momentum term of adam") +flags.DEFINE_float("smooth_weight", 0.5, "Weight for smoothness") +flags.DEFINE_float("explain_reg_weight", 0.0, "Weight for explanability regularization") +flags.DEFINE_integer("batch_size", 4, "The size of of a sample batch") +flags.DEFINE_integer("img_height", 128, "Image height") +flags.DEFINE_integer("img_width", 416, "Image width") +flags.DEFINE_integer("seq_length", 3, "Sequence length for each example") +flags.DEFINE_integer("max_steps", 200000, "Maximum number of training iterations") # “0000” was deleted, returned # "000" was deleted, returned # "0" was deleted # "0" was deleted +flags.DEFINE_integer("summary_freq", 100, "Logging every log_freq iterations") +flags.DEFINE_integer("save_latest_freq", 5000, \ + "Save the latest model every save_latest_freq iterations (overwrites the previous latest model)") +flags.DEFINE_boolean("continue_train", False, "Continue training from previous checkpoint") +FLAGS = flags.FLAGS + +def main(_): + seed = 8964 + tf.set_random_seed(seed) + np.random.seed(seed) + random.seed(seed) + + pp = pprint.PrettyPrinter() + pp.pprint(flags.FLAGS.__flags) + + if not os.path.exists(FLAGS.checkpoint_dir): + os.makedirs(FLAGS.checkpoint_dir) + + sfm = SfMLearner() + sfm.train(FLAGS) + +if __name__ == '__main__': + tf.app.run() + diff --git a/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/utils.py b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..db5bb069a28cf4e2410d6237bdafe223cd4fb57d --- /dev/null +++ b/TensorFlow/contrib/cv/SfMLearmer_ID2356_for_Tensorflow/utils.py @@ -0,0 +1,318 @@ +# +# Copyright 2017 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from __future__ import division +from npu_bridge.npu_init import * +import matplotlib.pyplot as plt +import numpy as np +import tensorflow as tf + +def gray2rgb(im, cmap='gray'): + cmap = plt.get_cmap(cmap) + rgba_img = cmap(im.astype(np.float32)) + rgb_img = np.delete(rgba_img, 3, 2) + return rgb_img + +def normalize_depth_for_display(depth, pc=95, crop_percent=0, normalizer=None, cmap='gray'): + # convert to disparity + depth = 1./(depth + 1e-6) + if normalizer is not None: + depth = depth/normalizer + else: + depth = depth/(np.percentile(depth, pc) + 1e-6) + depth = np.clip(depth, 0, 1) + depth = gray2rgb(depth, cmap=cmap) + keep_H = int(depth.shape[0] * (1-crop_percent)) + depth = depth[:keep_H] + depth = depth + return depth + +def euler2mat(z, y, x): + """Converts euler angles to rotation matrix + TODO: remove the dimension for 'N' (deprecated for converting all source + poses altogether) + Reference: https://github.com/pulkitag/pycaffe-utils/blob/master/rot_utils.py#L174 + Args: + z: rotation angle along z axis (in radians) -- size = [B, N] + y: rotation angle along y axis (in radians) -- size = [B, N] + x: rotation angle along x axis (in radians) -- size = [B, N] + Returns: + Rotation matrix corresponding to the euler angles -- size = [B, N, 3, 3] + """ + B = tf.shape(z)[0] + N = 1 + z = tf.clip_by_value(z, -np.pi, np.pi) + y = tf.clip_by_value(y, -np.pi, np.pi) + x = tf.clip_by_value(x, -np.pi, np.pi) + + # Expand to B x N x 1 x 1 + z = tf.expand_dims(tf.expand_dims(z, -1), -1) + y = tf.expand_dims(tf.expand_dims(y, -1), -1) + x = tf.expand_dims(tf.expand_dims(x, -1), -1) + + zeros = tf.zeros([B, N, 1, 1]) + ones = tf.ones([B, N, 1, 1]) + + cosz = tf.cos(z) + sinz = tf.sin(z) + rotz_1 = tf.concat([cosz, -sinz, zeros], axis=3) + rotz_2 = tf.concat([sinz, cosz, zeros], axis=3) + rotz_3 = tf.concat([zeros, zeros, ones], axis=3) + zmat = tf.concat([rotz_1, rotz_2, rotz_3], axis=2) + + cosy = tf.cos(y) + siny = tf.sin(y) + roty_1 = tf.concat([cosy, zeros, siny], axis=3) + roty_2 = tf.concat([zeros, ones, zeros], axis=3) + roty_3 = tf.concat([-siny,zeros, cosy], axis=3) + ymat = tf.concat([roty_1, roty_2, roty_3], axis=2) + + cosx = tf.cos(x) + sinx = tf.sin(x) + rotx_1 = tf.concat([ones, zeros, zeros], axis=3) + rotx_2 = tf.concat([zeros, cosx, -sinx], axis=3) + rotx_3 = tf.concat([zeros, sinx, cosx], axis=3) + xmat = tf.concat([rotx_1, rotx_2, rotx_3], axis=2) + + rotMat = tf.matmul(tf.matmul(xmat, ymat), zmat) + return rotMat + +def pose_vec2mat(vec): + """Converts 6DoF parameters to transformation matrix + Args: + vec: 6DoF parameters in the order of tx, ty, tz, rx, ry, rz -- [B, 6] + Returns: + A transformation matrix -- [B, 4, 4] + """ + batch_size, _ = vec.get_shape().as_list() + translation = tf.slice(vec, [0, 0], [-1, 3]) + translation = tf.expand_dims(translation, -1) + rx = tf.slice(vec, [0, 3], [-1, 1]) + ry = tf.slice(vec, [0, 4], [-1, 1]) + rz = tf.slice(vec, [0, 5], [-1, 1]) + rot_mat = euler2mat(rz, ry, rx) + rot_mat = tf.squeeze(rot_mat, axis=[1]) + filler = tf.constant([0.0, 0.0, 0.0, 1.0], shape=[1, 1, 4]) + filler = tf.tile(filler, [batch_size, 1, 1]) + transform_mat = tf.concat([rot_mat, translation], axis=2) + transform_mat = tf.concat([transform_mat, filler], axis=1) + return transform_mat + +def pixel2cam(depth, pixel_coords, intrinsics, is_homogeneous=True): + """Transforms coordinates in the pixel frame to the camera frame. + + Args: + depth: [batch, height, width] + pixel_coords: homogeneous pixel coordinates [batch, 3, height, width] + intrinsics: camera intrinsics [batch, 3, 3] + is_homogeneous: return in homogeneous coordinates + Returns: + Coords in the camera frame [batch, 3 (4 if homogeneous), height, width] + """ + batch, height, width = depth.get_shape().as_list() + depth = tf.reshape(depth, [batch, 1, -1]) + pixel_coords = tf.reshape(pixel_coords, [batch, 3, -1]) + cam_coords = tf.matmul(tf.matrix_inverse(intrinsics), pixel_coords) * depth + if is_homogeneous: + ones = tf.ones([batch, 1, height*width]) + cam_coords = tf.concat([cam_coords, ones], axis=1) + cam_coords = tf.reshape(cam_coords, [batch, -1, height, width]) + return cam_coords + +def cam2pixel(cam_coords, proj): + """Transforms coordinates in a camera frame to the pixel frame. + + Args: + cam_coords: [batch, 4, height, width] + proj: [batch, 4, 4] + Returns: + Pixel coordinates projected from the camera frame [batch, height, width, 2] + """ + batch, _, height, width = cam_coords.get_shape().as_list() + cam_coords = tf.reshape(cam_coords, [batch, 4, -1]) + unnormalized_pixel_coords = tf.matmul(proj, cam_coords) + x_u = tf.slice(unnormalized_pixel_coords, [0, 0, 0], [-1, 1, -1]) + y_u = tf.slice(unnormalized_pixel_coords, [0, 1, 0], [-1, 1, -1]) + z_u = tf.slice(unnormalized_pixel_coords, [0, 2, 0], [-1, 1, -1]) + x_n = x_u / (z_u + 1e-10) + y_n = y_u / (z_u + 1e-10) + pixel_coords = tf.concat([x_n, y_n], axis=1) + pixel_coords = tf.reshape(pixel_coords, [batch, 2, height, width]) + return tf.transpose(pixel_coords, perm=[0, 2, 3, 1]) + +def meshgrid(batch, height, width, is_homogeneous=True): + """Construct a 2D meshgrid. + + Args: + batch: batch size + height: height of the grid + width: width of the grid + is_homogeneous: whether to return in homogeneous coordinates + Returns: + x,y grid coordinates [batch, 2 (3 if homogeneous), height, width] + """ + x_t = tf.matmul(tf.ones(shape=tf.stack([height, 1])), + tf.transpose(tf.expand_dims( + tf.linspace(-1.0, 1.0, width), 1), [1, 0])) + y_t = tf.matmul(tf.expand_dims(tf.linspace(-1.0, 1.0, height), 1), + tf.ones(shape=tf.stack([1, width]))) + x_t = (x_t + 1.0) * 0.5 * tf.cast(width - 1, tf.float32) + y_t = (y_t + 1.0) * 0.5 * tf.cast(height - 1, tf.float32) + if is_homogeneous: + ones = tf.ones_like(x_t) + coords = tf.stack([x_t, y_t, ones], axis=0) + else: + coords = tf.stack([x_t, y_t], axis=0) + coords = tf.tile(tf.expand_dims(coords, 0), [batch, 1, 1, 1]) + return coords + +def projective_inverse_warp(img, depth, pose, intrinsics): + """Inverse warp a source image to the target image plane based on projection. + + Args: + img: the source image [batch, height_s, width_s, 3] + depth: depth map of the target image [batch, height_t, width_t] + pose: target to source camera transformation matrix [batch, 6], in the + order of tx, ty, tz, rx, ry, rz + intrinsics: camera intrinsics [batch, 3, 3] + Returns: + Source image inverse warped to the target image plane [batch, height_t, + width_t, 3] + """ + batch, height, width, _ = img.get_shape().as_list() + # Convert pose vector to matrix + pose = pose_vec2mat(pose) + # Construct pixel grid coordinates + pixel_coords = meshgrid(batch, height, width) + # Convert pixel coordinates to the camera frame + cam_coords = pixel2cam(depth, pixel_coords, intrinsics) + # Construct a 4x4 intrinsic matrix (TODO: can it be 3x4?) + filler = tf.constant([0.0, 0.0, 0.0, 1.0], shape=[1, 1, 4]) + filler = tf.tile(filler, [batch, 1, 1]) + intrinsics = tf.concat([intrinsics, tf.zeros([batch, 3, 1])], axis=2) + intrinsics = tf.concat([intrinsics, filler], axis=1) + # Get a 4x4 transformation matrix from 'target' camera frame to 'source' + # pixel frame. + proj_tgt_cam_to_src_pixel = tf.matmul(intrinsics, pose) + src_pixel_coords = cam2pixel(cam_coords, proj_tgt_cam_to_src_pixel) + output_img = bilinear_sampler(img, src_pixel_coords) + return output_img + +def bilinear_sampler(imgs, coords): + """Construct a new image by bilinear sampling from the input image. + + Points falling outside the source image boundary have value 0. + + Args: + imgs: source image to be sampled from [batch, height_s, width_s, channels] + coords: coordinates of source pixels to sample from [batch, height_t, + width_t, 2]. height_t/width_t correspond to the dimensions of the output + image (don't need to be the same as height_s/width_s). The two channels + correspond to x and y coordinates respectively. + Returns: + A new sampled image [batch, height_t, width_t, channels] + """ + def _repeat(x, n_repeats): + rep = tf.transpose( + tf.expand_dims(tf.ones(shape=tf.stack([ + n_repeats, + ])), 1), [1, 0]) + rep = tf.cast(rep, 'float32') + x = tf.matmul(tf.reshape(x, (-1, 1)), rep) + return tf.reshape(x, [-1]) + + with tf.name_scope('image_sampling'): + coords_x, coords_y = tf.split(coords, [1, 1], axis=3) + inp_size = imgs.get_shape() + coord_size = coords.get_shape() + out_size = coords.get_shape().as_list() + out_size[3] = imgs.get_shape().as_list()[3] + + coords_x = tf.cast(coords_x, 'float32') + coords_y = tf.cast(coords_y, 'float32') + + x0 = tf.floor(coords_x) + x1 = x0 + 1 + y0 = tf.floor(coords_y) + y1 = y0 + 1 + + y_max = tf.cast(tf.shape(imgs)[1] - 1, 'float32') + x_max = tf.cast(tf.shape(imgs)[2] - 1, 'float32') + zero = tf.zeros([1], dtype='float32') + + x0_safe = tf.clip_by_value(x0, zero, x_max) + y0_safe = tf.clip_by_value(y0, zero, y_max) + x1_safe = tf.clip_by_value(x1, zero, x_max) + y1_safe = tf.clip_by_value(y1, zero, y_max) + + ## bilinear interp weights, with points outside the grid having weight 0 + # wt_x0 = (x1 - coords_x) * tf.cast(tf.equal(x0, x0_safe), 'float32') + # wt_x1 = (coords_x - x0) * tf.cast(tf.equal(x1, x1_safe), 'float32') + # wt_y0 = (y1 - coords_y) * tf.cast(tf.equal(y0, y0_safe), 'float32') + # wt_y1 = (coords_y - y0) * tf.cast(tf.equal(y1, y1_safe), 'float32') + + wt_x0 = x1_safe - coords_x + wt_x1 = coords_x - x0_safe + wt_y0 = y1_safe - coords_y + wt_y1 = coords_y - y0_safe + + ## indices in the flat image to sample from + dim2 = tf.cast(inp_size[2], 'float32') + dim1 = tf.cast(inp_size[2] * inp_size[1], 'float32') + base = tf.reshape( + _repeat( + tf.cast(tf.range(coord_size[0]), 'float32') * dim1, + coord_size[1] * coord_size[2]), + [out_size[0], out_size[1], out_size[2], 1]) + + base_y0 = base + y0_safe * dim2 + base_y1 = base + y1_safe * dim2 + idx00 = tf.reshape(x0_safe + base_y0, [-1]) + idx01 = x0_safe + base_y1 + idx10 = x1_safe + base_y0 + idx11 = x1_safe + base_y1 + + ## sample from imgs + imgs_flat = tf.reshape(imgs, tf.stack([-1, inp_size[3]])) + imgs_flat = tf.cast(imgs_flat, 'float32') + im00 = tf.reshape(tf.gather(imgs_flat, tf.cast(idx00, 'int32')), out_size) + im01 = tf.reshape(tf.gather(imgs_flat, tf.cast(idx01, 'int32')), out_size) + im10 = tf.reshape(tf.gather(imgs_flat, tf.cast(idx10, 'int32')), out_size) + im11 = tf.reshape(tf.gather(imgs_flat, tf.cast(idx11, 'int32')), out_size) + + w00 = wt_x0 * wt_y0 + w01 = wt_x0 * wt_y1 + w10 = wt_x1 * wt_y0 + w11 = wt_x1 * wt_y1 + + output = tf.add_n([ + w00 * im00, w01 * im01, + w10 * im10, w11 * im11 + ]) + return output